@meteora-ag/dynamic-bonding-curve-sdk 1.2.2 → 1.2.4

package/dist/index.js

@@ -1,7 +1,8 @@
 // src/services/pool.ts
 import {
   PublicKey as PublicKey9,
-  Transaction as Transaction2
+  Transaction as Transaction2,
+  SYSVAR_INSTRUCTIONS_PUBKEY
 } from "@solana/web3.js";
 
 // src/types.ts
@@ -30,11 +31,12 @@ var GetFeeMode = /* @__PURE__ */ ((GetFeeMode2) => {
   GetFeeMode2[GetFeeMode2["OutputToken"] = 1] = "OutputToken";
   return GetFeeMode2;
 })(GetFeeMode || {});
-var FeeSchedulerMode = /* @__PURE__ */ ((FeeSchedulerMode2) => {
-  FeeSchedulerMode2[FeeSchedulerMode2["Linear"] = 0] = "Linear";
-  FeeSchedulerMode2[FeeSchedulerMode2["Exponential"] = 1] = "Exponential";
-  return FeeSchedulerMode2;
-})(FeeSchedulerMode || {});
+var BaseFeeMode = /* @__PURE__ */ ((BaseFeeMode3) => {
+  BaseFeeMode3[BaseFeeMode3["FeeSchedulerLinear"] = 0] = "FeeSchedulerLinear";
+  BaseFeeMode3[BaseFeeMode3["FeeSchedulerExponential"] = 1] = "FeeSchedulerExponential";
+  BaseFeeMode3[BaseFeeMode3["RateLimiter"] = 2] = "RateLimiter";
+  return BaseFeeMode3;
+})(BaseFeeMode || {});
 var MigrationFeeOption = /* @__PURE__ */ ((MigrationFeeOption2) => {
   MigrationFeeOption2[MigrationFeeOption2["FixedBps25"] = 0] = "FixedBps25";
   MigrationFeeOption2[MigrationFeeOption2["FixedBps30"] = 1] = "FixedBps30";
@@ -77,12 +79,17 @@ var MAX_SQRT_PRICE = new BN("79226673521066979257578248091");
 var RESOLUTION = 64;
 var ONE_Q64 = new BN(1).shln(RESOLUTION);
 var FEE_DENOMINATOR = 1e9;
-var MAX_FEE_NUMERATOR = 5e8;
+var MAX_FEE_BPS = 9900;
+var MIN_FEE_BPS = 1;
+var MIN_FEE_NUMERATOR = 1e5;
+var MAX_FEE_NUMERATOR = 99e7;
 var BASIS_POINT_MAX = 1e4;
 var MAX_CURVE_POINT = 16;
 var PARTNER_SURPLUS_SHARE = 80;
 var SWAP_BUFFER_PERCENTAGE = 25;
 var MAX_SWALLOW_PERCENTAGE = 20;
+var MAX_RATE_LIMITER_DURATION_IN_SECONDS = 43200;
+var MAX_RATE_LIMITER_DURATION_IN_SLOTS = 108e3;
 var SLOT_DURATION = 400;
 var TIMESTAMP_DURATION = 1e3;
 var DYNAMIC_BONDING_CURVE_PROGRAM_ID = new PublicKey(
@@ -696,7 +703,7 @@ var getPercentageSupplyOnMigration = (initialMarketCap, migrationMarketCap, lock
 var getMigrationQuoteAmount = (migrationMarketCap, percentageSupplyOnMigration) => {
   return migrationMarketCap.mul(percentageSupplyOnMigration).div(new Decimal2(100));
 };
-function getBaseFeeParams(startingBaseFeeBps, endingBaseFeeBps, feeSchedulerMode, numberOfPeriod, totalDuration) {
+function getFeeSchedulerParams(startingBaseFeeBps, endingBaseFeeBps, baseFeeMode, numberOfPeriod, totalDuration) {
   if (startingBaseFeeBps == endingBaseFeeBps) {
     if (numberOfPeriod != 0 || totalDuration != 0) {
       throw new Error(
@@ -705,20 +712,18 @@ function getBaseFeeParams(startingBaseFeeBps, endingBaseFeeBps, feeSchedulerMode
     }
     return {
       cliffFeeNumerator: bpsToFeeNumerator(startingBaseFeeBps),
-      numberOfPeriod: 0,
-      periodFrequency: new BN6(0),
-      reductionFactor: new BN6(0),
-      feeSchedulerMode: 0 /* Linear */
+      firstFactor: 0,
+      secondFactor: new BN6(0),
+      thirdFactor: new BN6(0),
+      baseFeeMode: 0 /* FeeSchedulerLinear */
     };
   }
   if (numberOfPeriod <= 0) {
     throw new Error("Total periods must be greater than zero");
   }
-  if (startingBaseFeeBps > feeNumeratorToBps(new BN6(MAX_FEE_NUMERATOR))) {
+  if (startingBaseFeeBps > MAX_FEE_BPS) {
     throw new Error(
-      `startingBaseFeeBps (${startingBaseFeeBps} bps) exceeds maximum allowed value of ${feeNumeratorToBps(
-        new BN6(MAX_FEE_NUMERATOR)
-      )} bps`
+      `startingBaseFeeBps (${startingBaseFeeBps} bps) exceeds maximum allowed value of ${MAX_FEE_BPS} bps`
     );
   }
   if (endingBaseFeeBps > startingBaseFeeBps) {
@@ -735,7 +740,7 @@ function getBaseFeeParams(startingBaseFeeBps, endingBaseFeeBps, feeSchedulerMode
   const minBaseFeeNumerator = bpsToFeeNumerator(endingBaseFeeBps);
   const periodFrequency = new BN6(totalDuration / numberOfPeriod);
   let reductionFactor;
-  if (feeSchedulerMode == 0 /* Linear */) {
+  if (baseFeeMode == 0 /* FeeSchedulerLinear */) {
     const totalReduction = maxBaseFeeNumerator.sub(minBaseFeeNumerator);
     reductionFactor = totalReduction.divn(numberOfPeriod);
   } else {
@@ -745,15 +750,15 @@ function getBaseFeeParams(startingBaseFeeBps, endingBaseFeeBps, feeSchedulerMode
   }
   return {
     cliffFeeNumerator: maxBaseFeeNumerator,
-    numberOfPeriod,
-    periodFrequency,
-    reductionFactor,
-    feeSchedulerMode
+    firstFactor: numberOfPeriod,
+    secondFactor: periodFrequency,
+    thirdFactor: reductionFactor,
+    baseFeeMode
   };
 }
-function getMinBaseFeeBps(cliffFeeNumerator, numberOfPeriod, reductionFactor, feeSchedulerMode) {
+function calculateFeeSchedulerEndingBaseFeeBps(cliffFeeNumerator, numberOfPeriod, reductionFactor, baseFeeMode) {
   let baseFeeNumerator;
-  if (feeSchedulerMode == 0 /* Linear */) {
+  if (baseFeeMode == 0 /* FeeSchedulerLinear */) {
     baseFeeNumerator = cliffFeeNumerator - numberOfPeriod * reductionFactor;
   } else {
     const decayRate = 1 - reductionFactor / BASIS_POINT_MAX;
@@ -761,6 +766,53 @@ function getMinBaseFeeBps(cliffFeeNumerator, numberOfPeriod, reductionFactor, fe
   }
   return Math.max(0, baseFeeNumerator / FEE_DENOMINATOR * BASIS_POINT_MAX);
 }
+function getRateLimiterParams(baseFeeBps, feeIncrementBps, referenceAmount, maxLimiterDuration, tokenQuoteDecimal, 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");
+  }
+  if (baseFeeBps > MAX_FEE_BPS) {
+    throw new Error(
+      `Base fee (${baseFeeBps} bps) exceeds maximum allowed value of ${MAX_FEE_BPS} bps`
+    );
+  }
+  if (feeIncrementBps > MAX_FEE_BPS) {
+    throw new Error(
+      `Fee increment (${feeIncrementBps} bps) exceeds maximum allowed value of ${MAX_FEE_BPS} bps`
+    );
+  }
+  if (feeIncrementNumerator.gte(new BN6(FEE_DENOMINATOR))) {
+    throw new Error(
+      "Fee increment numerator must be less than FEE_DENOMINATOR"
+    );
+  }
+  const deltaNumerator = new BN6(MAX_FEE_NUMERATOR).sub(cliffFeeNumerator);
+  const maxIndex = deltaNumerator.div(feeIncrementNumerator);
+  if (maxIndex.lt(new BN6(1))) {
+    throw new Error("Fee increment is too large for the given base fee");
+  }
+  if (cliffFeeNumerator.lt(new BN6(MIN_FEE_NUMERATOR)) || cliffFeeNumerator.gt(new BN6(MAX_FEE_NUMERATOR))) {
+    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,
+    tokenQuoteDecimal
+  );
+  return {
+    cliffFeeNumerator,
+    firstFactor: feeIncrementBps,
+    secondFactor: new BN6(maxLimiterDuration),
+    thirdFactor: new BN6(referenceAmountInLamports),
+    baseFeeMode: 2 /* RateLimiter */
+  };
+}
 function getDynamicFeeParams(baseFeeBps, maxPriceChangeBps = MAX_PRICE_CHANGE_BPS_DEFAULT) {
   if (maxPriceChangeBps > MAX_PRICE_CHANGE_BPS_DEFAULT) {
     throw new Error(
@@ -881,6 +933,46 @@ var getTwoCurve = (migrationSqrtPrice, midSqrtPrice, initialSqrtPrice, swapAmoun
     ]
   };
 };
+function checkRateLimiterApplied(baseFeeMode, swapBaseForQuote, currentPoint, activationPoint, maxLimiterDuration) {
+  return baseFeeMode === 2 /* RateLimiter */ && !swapBaseForQuote && currentPoint.gte(activationPoint) && currentPoint.lte(activationPoint.add(maxLimiterDuration));
+}
+function getBaseFeeParams(baseFeeParams, tokenQuoteDecimal, 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
+    } = baseFeeParams.rateLimiterParam;
+    return getRateLimiterParams(
+      baseFeeBps,
+      feeIncrementBps,
+      referenceAmount,
+      maxLimiterDuration,
+      tokenQuoteDecimal,
+      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
+    );
+  }
+}
 
 // src/helpers/accounts.ts
 import { PublicKey as PublicKey4 } from "@solana/web3.js";
@@ -1143,15 +1235,160 @@ function deriveBaseKeyForLocker(virtualPool) {
 }
 
 // src/helpers/validation.ts
-import BN7 from "bn.js";
+import BN8 from "bn.js";
 import { PublicKey as PublicKey5 } from "@solana/web3.js";
 import Decimal3 from "decimal.js";
-function validatePoolFees(poolFees) {
+
+// src/math/rateLimiter.ts
+import BN7 from "bn.js";
+function getMaxIndex(cliffFeeNumerator, feeIncrementBps) {
+  const deltaNumerator = new BN7(MAX_FEE_NUMERATOR).sub(cliffFeeNumerator);
+  const feeIncrementNumerator = mulDiv(
+    new BN7(feeIncrementBps),
+    new BN7(FEE_DENOMINATOR),
+    new BN7(BASIS_POINT_MAX),
+    1 /* Down */
+  );
+  return deltaNumerator.div(feeIncrementNumerator);
+}
+function getFeeNumeratorOnRateLimiter(cliffFeeNumerator, referenceAmount, feeIncrementBps, inputAmount) {
+  if (inputAmount.lte(referenceAmount)) {
+    return cliffFeeNumerator;
+  }
+  const c = new BN7(cliffFeeNumerator);
+  const diff = inputAmount.sub(referenceAmount);
+  const a = new BN7(diff.div(referenceAmount));
+  const b = new BN7(diff.mod(referenceAmount));
+  const maxIndex = new BN7(getMaxIndex(cliffFeeNumerator, feeIncrementBps));
+  const i = mulDiv(
+    new BN7(feeIncrementBps),
+    new BN7(FEE_DENOMINATOR),
+    new BN7(BASIS_POINT_MAX),
+    1 /* Down */
+  );
+  const x0 = new BN7(referenceAmount);
+  const one = new BN7(1);
+  const two = new BN7(2);
+  let tradingFeeNumerator;
+  if (a.lt(maxIndex)) {
+    let numerator1 = c.add(c.mul(a)).add(i.mul(a).mul(a.add(one)).div(two));
+    let numerator2 = c.add(i.mul(a.add(one)));
+    let firstFee = x0.mul(numerator1);
+    let secondFee = b.mul(numerator2);
+    tradingFeeNumerator = firstFee.add(secondFee);
+  } else {
+    let numerator1 = c.add(c.mul(maxIndex)).add(i.mul(maxIndex).mul(maxIndex.add(one)).div(two));
+    let numerator2 = new BN7(MAX_FEE_NUMERATOR);
+    let firstFee = x0.mul(numerator1);
+    let d = a.sub(maxIndex);
+    let leftAmount = d.mul(x0).add(b);
+    let secondFee = leftAmount.mul(numerator2);
+    tradingFeeNumerator = firstFee.add(secondFee);
+  }
+  const denominator = new BN7(FEE_DENOMINATOR);
+  const tradingFee = tradingFeeNumerator.add(denominator).sub(one).div(denominator);
+  const feeNumerator = mulDiv(
+    tradingFee,
+    new BN7(FEE_DENOMINATOR),
+    inputAmount,
+    0 /* Up */
+  );
+  return BN7.min(feeNumerator, new BN7(MAX_FEE_NUMERATOR));
+}
+
+// src/helpers/validation.ts
+function validatePoolFees(poolFees, collectFeeMode, activationType) {
   if (!poolFees) return false;
   if (poolFees.baseFee) {
-    if (poolFees.baseFee.cliffFeeNumerator.lte(new BN7(0))) {
+    if (poolFees.baseFee.cliffFeeNumerator.lte(new BN8(0))) {
       return false;
     }
+    if (poolFees.baseFee.baseFeeMode === 0 /* FeeSchedulerLinear */ || poolFees.baseFee.baseFeeMode === 1 /* FeeSchedulerExponential */) {
+      if (!validateFeeScheduler(poolFees.baseFee)) {
+        return false;
+      }
+    }
+    if (poolFees.baseFee.baseFeeMode === 2 /* RateLimiter */) {
+      if (!validateFeeRateLimiter(
+        poolFees.baseFee,
+        collectFeeMode,
+        activationType
+      )) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+function validateFeeScheduler(feeScheduler) {
+  if (!feeScheduler) return true;
+  if (feeScheduler.firstFactor !== 0 || feeScheduler.secondFactor.gt(new BN8(0)) || feeScheduler.thirdFactor.gt(new BN8(0))) {
+    if (feeScheduler.firstFactor === 0 || feeScheduler.secondFactor.eq(new BN8(0)) || feeScheduler.thirdFactor.eq(new BN8(0))) {
+      return false;
+    }
+  }
+  if (feeScheduler.cliffFeeNumerator.lte(new BN8(0))) {
+    return false;
+  }
+  if (feeScheduler.baseFeeMode !== 0 /* FeeSchedulerLinear */ && feeScheduler.baseFeeMode !== 1 /* FeeSchedulerExponential */) {
+    return false;
+  }
+  if (feeScheduler.baseFeeMode === 0 /* FeeSchedulerLinear */) {
+    const finalFee = feeScheduler.cliffFeeNumerator.sub(
+      feeScheduler.secondFactor.mul(new BN8(feeScheduler.firstFactor))
+    );
+    if (finalFee.lt(new BN8(0))) {
+      return false;
+    }
+  }
+  const minFeeNumerator = feeScheduler.cliffFeeNumerator.sub(
+    feeScheduler.secondFactor.mul(new BN8(feeScheduler.firstFactor))
+  );
+  const maxFeeNumerator = feeScheduler.cliffFeeNumerator;
+  if (minFeeNumerator.gte(new BN8(FEE_DENOMINATOR)) || maxFeeNumerator.gte(new BN8(FEE_DENOMINATOR))) {
+    return false;
+  }
+  if (minFeeNumerator.lt(new BN8(MIN_FEE_NUMERATOR)) || maxFeeNumerator.gt(new BN8(MAX_FEE_NUMERATOR))) {
+    return false;
+  }
+  return true;
+}
+function validateFeeRateLimiter(feeRateLimiter, collectFeeMode, activationType) {
+  if (!feeRateLimiter) return true;
+  if (collectFeeMode !== 0 /* OnlyQuote */) {
+    return false;
+  }
+  if (!feeRateLimiter.firstFactor && !feeRateLimiter.secondFactor && !feeRateLimiter.thirdFactor) {
+    return true;
+  }
+  if (!feeRateLimiter.firstFactor || !feeRateLimiter.secondFactor || !feeRateLimiter.thirdFactor) {
+    return false;
+  }
+  const maxDuration = activationType === 0 /* Slot */ ? MAX_RATE_LIMITER_DURATION_IN_SLOTS : MAX_RATE_LIMITER_DURATION_IN_SECONDS;
+  if (feeRateLimiter.secondFactor.gt(new BN8(maxDuration))) {
+    return false;
+  }
+  const feeIncrementNumerator = bpsToFeeNumerator(feeRateLimiter.firstFactor);
+  if (feeIncrementNumerator.gte(new BN8(FEE_DENOMINATOR))) {
+    return false;
+  }
+  if (feeRateLimiter.cliffFeeNumerator.lt(new BN8(MIN_FEE_NUMERATOR)) || feeRateLimiter.cliffFeeNumerator.gt(new BN8(MAX_FEE_NUMERATOR))) {
+    return false;
+  }
+  const minFeeNumerator = getFeeNumeratorOnRateLimiter(
+    feeRateLimiter.cliffFeeNumerator,
+    feeRateLimiter.thirdFactor,
+    new BN8(feeRateLimiter.firstFactor),
+    new BN8(0)
+  );
+  const maxFeeNumerator = getFeeNumeratorOnRateLimiter(
+    feeRateLimiter.cliffFeeNumerator,
+    feeRateLimiter.thirdFactor,
+    new BN8(feeRateLimiter.firstFactor),
+    new BN8(Number.MAX_SAFE_INTEGER)
+  );
+  if (minFeeNumerator.lt(new BN8(MIN_FEE_NUMERATOR)) || maxFeeNumerator.gt(new BN8(MAX_FEE_NUMERATOR))) {
+    return false;
   }
   return true;
 }
@@ -1192,7 +1429,7 @@ function validateCurve(curve, sqrtStartPrice) {
   if (!curve || curve.length === 0 || curve.length > MAX_CURVE_POINT) {
     return false;
   }
-  if (curve[0]?.sqrtPrice.lte(sqrtStartPrice) || curve[0]?.liquidity.lte(new BN7(0)) || curve[0]?.sqrtPrice.gt(new BN7(MAX_SQRT_PRICE))) {
+  if (curve[0]?.sqrtPrice.lte(sqrtStartPrice) || curve[0]?.liquidity.lte(new BN8(0)) || curve[0]?.sqrtPrice.gt(new BN8(MAX_SQRT_PRICE))) {
     return false;
   }
   for (let i = 1; i < curve.length; i++) {
@@ -1201,11 +1438,11 @@ function validateCurve(curve, sqrtStartPrice) {
     if (!currentPoint || !previousPoint) {
       return false;
     }
-    if (currentPoint.sqrtPrice.lte(previousPoint.sqrtPrice) || currentPoint.liquidity.lte(new BN7(0))) {
+    if (currentPoint.sqrtPrice.lte(previousPoint.sqrtPrice) || currentPoint.liquidity.lte(new BN8(0))) {
       return false;
     }
   }
-  return !curve[curve.length - 1]?.sqrtPrice.gt(new BN7(MAX_SQRT_PRICE));
+  return !curve[curve.length - 1]?.sqrtPrice.gt(new BN8(MAX_SQRT_PRICE));
 }
 function validateTokenSupply(tokenSupply, leftoverReceiver, swapBaseAmount, migrationBaseAmount, lockedVesting, swapBaseAmountBuffer) {
   if (!tokenSupply) return true;
@@ -1229,11 +1466,11 @@ function validateTokenSupply(tokenSupply, leftoverReceiver, swapBaseAmount, migr
     lockedVesting
   );
   return !(minimumBaseSupplyWithoutBuffer.gt(
-    new BN7(tokenSupply.postMigrationTokenSupply)
-  ) || new BN7(tokenSupply.postMigrationTokenSupply).gt(
-    new BN7(tokenSupply.preMigrationTokenSupply)
+    new BN8(tokenSupply.postMigrationTokenSupply)
+  ) || new BN8(tokenSupply.postMigrationTokenSupply).gt(
+    new BN8(tokenSupply.preMigrationTokenSupply)
   ) || minimumBaseSupplyWithBuffer.gt(
-    new BN7(tokenSupply.preMigrationTokenSupply)
+    new BN8(tokenSupply.preMigrationTokenSupply)
   ));
 }
 function validateTokenUpdateAuthorityOptions(option) {
@@ -1246,7 +1483,11 @@ function validateConfigParameters(configParam) {
   if (!configParam.poolFees) {
     throw new Error("Pool fees are required");
   }
-  if (!validatePoolFees(configParam.poolFees)) {
+  if (!validatePoolFees(
+    configParam.poolFees,
+    configParam.collectFeeMode,
+    configParam.activationType
+  )) {
     throw new Error("Invalid pool fees");
   }
   if (!validateCollectFeeMode(configParam.collectFeeMode)) {
@@ -1284,10 +1525,10 @@ function validateConfigParameters(configParam) {
   )) {
     throw new Error("Sum of LP percentages must equal 100");
   }
-  if (configParam.migrationQuoteThreshold.lte(new BN7(0))) {
+  if (configParam.migrationQuoteThreshold.lte(new BN8(0))) {
     throw new Error("Migration quote threshold must be greater than 0");
   }
-  if (new BN7(configParam.sqrtStartPrice).lt(new BN7(MIN_SQRT_PRICE)) || new BN7(configParam.sqrtStartPrice).gte(new BN7(MAX_SQRT_PRICE))) {
+  if (new BN8(configParam.sqrtStartPrice).lt(new BN8(MIN_SQRT_PRICE)) || new BN8(configParam.sqrtStartPrice).gte(new BN8(MAX_SQRT_PRICE))) {
     throw new Error("Invalid sqrt start price");
   }
   if (!validateCurve(configParam.curve, configParam.sqrtStartPrice)) {
@@ -1297,10 +1538,10 @@ function validateConfigParameters(configParam) {
     try {
       const totalAmount = configParam.lockedVesting.cliffUnlockAmount.add(
         configParam.lockedVesting.amountPerPeriod.mul(
-          new BN7(configParam.lockedVesting.numberOfPeriod)
+          new BN8(configParam.lockedVesting.numberOfPeriod)
         )
       );
-      if (configParam.lockedVesting.frequency.eq(new BN7(0)) || totalAmount.eq(new BN7(0))) {
+      if (configParam.lockedVesting.frequency.eq(new BN8(0)) || totalAmount.eq(new BN8(0))) {
         throw new Error("Invalid vesting parameters");
       }
     } catch (error) {
@@ -1361,7 +1602,7 @@ async function validateBalance(connection, owner, inputMint, amountIn, inputToke
   } else {
     try {
       const tokenBalance = await connection.getTokenAccountBalance(inputTokenAccount);
-      const balance = new BN7(tokenBalance.value.amount);
+      const balance = new BN8(tokenBalance.value.amount);
       if (balance.lt(amountIn)) {
         throw new Error(
           `Insufficient token balance. Required: ${amountIn.toString()}, Found: ${balance.toString()}`
@@ -1376,7 +1617,7 @@ async function validateBalance(connection, owner, inputMint, amountIn, inputToke
   return true;
 }
 function validateSwapAmount(amountIn) {
-  if (amountIn.lte(new BN7(0))) {
+  if (amountIn.lte(new BN8(0))) {
     throw new Error("Swap amount must be greater than 0");
   }
   return true;
@@ -1384,7 +1625,7 @@ function validateSwapAmount(amountIn) {
 
 // src/helpers/buildCurve.ts
 import Decimal4 from "decimal.js";
-import BN8 from "bn.js";
+import BN9 from "bn.js";
 function buildCurve(buildCurveParam) {
   let {
     totalTokenSupply,
@@ -1405,21 +1646,13 @@ function buildCurve(buildCurveParam) {
     creatorTradingFeePercentage,
     leftover,
     tokenUpdateAuthority,
-    migrationFee
+    migrationFee,
+    baseFeeParams
   } = buildCurveParam;
-  const {
-    startingFeeBps,
-    endingFeeBps,
-    numberOfPeriod,
-    feeSchedulerMode,
-    totalDuration
-  } = buildCurveParam.feeSchedulerParam;
-  const baseFeeParams = getBaseFeeParams(
-    startingFeeBps,
-    endingFeeBps,
-    feeSchedulerMode,
-    numberOfPeriod,
-    totalDuration
+  const baseFee = getBaseFeeParams(
+    baseFeeParams,
+    tokenQuoteDecimal,
+    activationType
   );
   const {
     totalLockedVestingAmount,
@@ -1436,7 +1669,7 @@ function buildCurve(buildCurveParam) {
     cliffDurationFromMigrationTime,
     tokenBaseDecimal
   );
-  const migrationBaseSupply = new BN8(totalTokenSupply).mul(new BN8(percentageSupplyOnMigration)).div(new BN8(100));
+  const migrationBaseSupply = new BN9(totalTokenSupply).mul(new BN9(percentageSupplyOnMigration)).div(new BN9(100));
   const totalSupply = convertToLamports(totalTokenSupply, tokenBaseDecimal);
   const migrationQuoteAmount = getMigrationQuoteAmountFromMigrationQuoteThreshold(
     new Decimal4(migrationQuoteThreshold),
@@ -1496,9 +1729,11 @@ function buildCurve(buildCurveParam) {
   const instructionParams = {
     poolFees: {
       baseFee: {
-        ...baseFeeParams
+        ...baseFee
       },
-      dynamicFee: dynamicFeeEnabled ? getDynamicFeeParams(endingFeeBps) : null
+      dynamicFee: dynamicFeeEnabled ? getDynamicFeeParams(
+        baseFeeParams.baseFeeMode === 2 /* RateLimiter */ ? baseFeeParams.rateLimiterParam.baseFeeBps : baseFeeParams.feeSchedulerParam.endingFeeBps
+      ) : null
     },
     activationType,
     collectFeeMode,
@@ -1591,21 +1826,13 @@ function buildCurveWithTwoSegments(buildCurveWithTwoSegmentsParam) {
     dynamicFeeEnabled,
     migrationFeeOption,
     migrationFee,
-    tokenUpdateAuthority
+    tokenUpdateAuthority,
+    baseFeeParams
   } = buildCurveWithTwoSegmentsParam;
-  const {
-    startingFeeBps,
-    endingFeeBps,
-    numberOfPeriod,
-    feeSchedulerMode,
-    totalDuration
-  } = buildCurveWithTwoSegmentsParam.feeSchedulerParam;
-  const baseFeeParams = getBaseFeeParams(
-    startingFeeBps,
-    endingFeeBps,
-    feeSchedulerMode,
-    numberOfPeriod,
-    totalDuration
+  const baseFee = getBaseFeeParams(
+    baseFeeParams,
+    tokenQuoteDecimal,
+    activationType
   );
   const {
     totalLockedVestingAmount,
@@ -1622,7 +1849,7 @@ function buildCurveWithTwoSegments(buildCurveWithTwoSegmentsParam) {
     cliffDurationFromMigrationTime,
     tokenBaseDecimal
   );
-  let migrationBaseSupply = new BN8(totalTokenSupply).mul(new BN8(percentageSupplyOnMigration)).div(new BN8(100));
+  let migrationBaseSupply = new BN9(totalTokenSupply).mul(new BN9(percentageSupplyOnMigration)).div(new BN9(100));
   let totalSupply = convertToLamports(totalTokenSupply, tokenBaseDecimal);
   let migrationQuoteAmount = getMigrationQuoteAmount(
     new Decimal4(migrationMarketCap),
@@ -1661,19 +1888,19 @@ function buildCurveWithTwoSegments(buildCurveWithTwoSegmentsParam) {
     tokenQuoteDecimal
   );
   let midSqrtPriceDecimal1 = new Decimal4(migrateSqrtPrice.toString()).mul(new Decimal4(initialSqrtPrice.toString())).sqrt();
-  let midSqrtPrice1 = new BN8(midSqrtPriceDecimal1.floor().toFixed());
+  let midSqrtPrice1 = new BN9(midSqrtPriceDecimal1.floor().toFixed());
   let numerator1 = new Decimal4(initialSqrtPrice.toString());
   let numerator2 = Decimal4.pow(migrateSqrtPrice.toString(), 3);
   let product1 = numerator1.mul(numerator2);
   let midSqrtPriceDecimal2 = Decimal4.pow(product1, 0.25);
-  let midSqrtPrice2 = new BN8(midSqrtPriceDecimal2.floor().toFixed());
+  let midSqrtPrice2 = new BN9(midSqrtPriceDecimal2.floor().toFixed());
   let numerator3 = Decimal4.pow(initialSqrtPrice.toString(), 3);
   let numerator4 = new Decimal4(migrateSqrtPrice.toString());
   let product2 = numerator3.mul(numerator4);
   let midSqrtPriceDecimal3 = Decimal4.pow(product2, 0.25);
-  let midSqrtPrice3 = new BN8(midSqrtPriceDecimal3.floor().toFixed());
+  let midSqrtPrice3 = new BN9(midSqrtPriceDecimal3.floor().toFixed());
   let midPrices = [midSqrtPrice1, midSqrtPrice2, midSqrtPrice3];
-  let sqrtStartPrice = new BN8(0);
+  let sqrtStartPrice = new BN9(0);
   let curve = [];
   for (let i = 0; i < midPrices.length; i++) {
     const result = getTwoCurve(
@@ -1707,9 +1934,11 @@ function buildCurveWithTwoSegments(buildCurveWithTwoSegmentsParam) {
   const instructionParams = {
     poolFees: {
       baseFee: {
-        ...baseFeeParams
+        ...baseFee
       },
-      dynamicFee: dynamicFeeEnabled ? getDynamicFeeParams(endingFeeBps) : null
+      dynamicFee: dynamicFeeEnabled ? getDynamicFeeParams(
+        baseFeeParams.baseFeeMode === 2 /* RateLimiter */ ? baseFeeParams.rateLimiterParam.baseFeeBps : baseFeeParams.feeSchedulerParam.endingFeeBps
+      ) : null
     },
     activationType,
     collectFeeMode,
@@ -1758,21 +1987,13 @@ function buildCurveWithLiquidityWeights(buildCurveWithLiquidityWeightsParam) {
     migrationMarketCap,
     liquidityWeights,
     migrationFee,
-    tokenUpdateAuthority
+    tokenUpdateAuthority,
+    baseFeeParams
   } = buildCurveWithLiquidityWeightsParam;
-  const {
-    startingFeeBps,
-    endingFeeBps,
-    numberOfPeriod,
-    feeSchedulerMode,
-    totalDuration
-  } = buildCurveWithLiquidityWeightsParam.feeSchedulerParam;
-  const baseFeeParams = getBaseFeeParams(
-    startingFeeBps,
-    endingFeeBps,
-    feeSchedulerMode,
-    numberOfPeriod,
-    totalDuration
+  const baseFee = getBaseFeeParams(
+    baseFeeParams,
+    tokenQuoteDecimal,
+    activationType
   );
   const {
     totalLockedVestingAmount,
@@ -1873,9 +2094,11 @@ function buildCurveWithLiquidityWeights(buildCurveWithLiquidityWeightsParam) {
   const instructionParams = {
     poolFees: {
       baseFee: {
-        ...baseFeeParams
+        ...baseFee
       },
-      dynamicFee: dynamicFeeEnabled ? getDynamicFeeParams(endingFeeBps) : null
+      dynamicFee: dynamicFeeEnabled ? getDynamicFeeParams(
+        baseFeeParams.baseFeeMode === 2 /* RateLimiter */ ? baseFeeParams.rateLimiterParam.baseFeeBps : baseFeeParams.feeSchedulerParam.endingFeeBps
+      ) : null
     },
     activationType,
     collectFeeMode,
@@ -5820,6 +6043,21 @@ var idl_default = {
       code: 6040,
       name: "MigrationFeeHasBeenWithdraw",
       msg: "Migration fee has been withdraw"
+    },
+    {
+      code: 6041,
+      name: "InvalidBaseFeeMode",
+      msg: "Invalid base fee mode"
+    },
+    {
+      code: 6042,
+      name: "InvalidFeeRateLimiter",
+      msg: "Invalid fee rate limiter"
+    },
+    {
+      code: 6043,
+      name: "FailToValidateSingleSwapInstruction",
+      msg: "Fail to validate single swap instruction in rate limiter"
     }
   ],
   types: [
@@ -5837,19 +6075,19 @@ var idl_default = {
             type: "u64"
           },
           {
-            name: "period_frequency",
+            name: "second_factor",
             type: "u64"
           },
           {
-            name: "reduction_factor",
+            name: "third_factor",
             type: "u64"
           },
           {
-            name: "number_of_period",
+            name: "first_factor",
             type: "u16"
           },
           {
-            name: "fee_scheduler_mode",
+            name: "base_fee_mode",
             type: "u8"
           },
           {
@@ -5874,19 +6112,19 @@ var idl_default = {
             type: "u64"
           },
           {
-            name: "number_of_period",
+            name: "first_factor",
             type: "u16"
           },
           {
-            name: "period_frequency",
+            name: "second_factor",
             type: "u64"
           },
           {
-            name: "reduction_factor",
+            name: "third_factor",
             type: "u64"
           },
           {
-            name: "fee_scheduler_mode",
+            name: "base_fee_mode",
             type: "u8"
           }
         ]
@@ -20886,16 +21124,26 @@ import { NATIVE_MINT as NATIVE_MINT3, TOKEN_2022_PROGRAM_ID as TOKEN_2022_PROGRA
 import { TOKEN_PROGRAM_ID as TOKEN_PROGRAM_ID3 } from "@solana/spl-token";
 
 // src/math/swapQuote.ts
-import BN10 from "bn.js";
+import BN12 from "bn.js";
 
 // src/math/feeMath.ts
-import BN9 from "bn.js";
-function getFeeInPeriod(cliffFeeNumerator, reductionFactor, period) {
+import BN11 from "bn.js";
+
+// src/math/feeScheduler.ts
+import BN10 from "bn.js";
+function getFeeNumeratorOnLinearFeeScheduler(cliffFeeNumerator, reductionFactor, period) {
+  const reduction = SafeMath.mul(new BN10(period), reductionFactor);
+  if (reduction.gt(cliffFeeNumerator)) {
+    return new BN10(0);
+  }
+  return SafeMath.sub(cliffFeeNumerator, reduction);
+}
+function getFeeNumeratorOnExponentialFeeScheduler(cliffFeeNumerator, reductionFactor, period) {
   if (period === 0) {
     return cliffFeeNumerator;
   }
   if (period === 1) {
-    const basisPointMax2 = new BN9(BASIS_POINT_MAX);
+    const basisPointMax2 = new BN10(BASIS_POINT_MAX);
     return mulDiv(
       cliffFeeNumerator,
       basisPointMax2.sub(reductionFactor),
@@ -20903,53 +21151,106 @@ function getFeeInPeriod(cliffFeeNumerator, reductionFactor, period) {
       1 /* Down */
     );
   }
-  const basisPointMax = new BN9(BASIS_POINT_MAX);
-  const ONE_Q642 = new BN9(1).shln(64);
+  const basisPointMax = new BN10(BASIS_POINT_MAX);
+  const ONE_Q642 = new BN10(1).shln(64);
   const reductionFactorScaled = SafeMath.div(
     SafeMath.shl(reductionFactor, 64),
     basisPointMax
   );
   let base = SafeMath.sub(ONE_Q642, reductionFactorScaled);
-  const result = pow(base, new BN9(period));
+  const result = pow(base, new BN10(period));
   return SafeMath.div(SafeMath.mul(cliffFeeNumerator, result), ONE_Q642);
 }
-function getCurrentBaseFeeNumerator(baseFee, currentPoint, activationPoint) {
-  if (baseFee.periodFrequency.isZero()) {
-    return baseFee.cliffFeeNumerator;
-  }
-  let period;
-  if (currentPoint.lt(activationPoint)) {
-    period = baseFee.numberOfPeriod;
-  } else {
-    const elapsedPoints = SafeMath.sub(currentPoint, activationPoint);
-    const periodCount = SafeMath.div(elapsedPoints, baseFee.periodFrequency);
-    period = Math.min(
-      parseInt(periodCount.toString()),
-      baseFee.numberOfPeriod
+
+// src/math/feeMath.ts
+function getBaseFeeNumerator(baseFee, tradeDirection, currentPoint, activationPoint, inputAmount) {
+  const baseFeeMode = baseFee.baseFeeMode;
+  if (baseFeeMode === 2 /* RateLimiter */) {
+    const feeIncrementBps = baseFee.firstFactor;
+    const maxLimiterDuration = baseFee.secondFactor;
+    const referenceAmount = baseFee.thirdFactor;
+    const isBaseToQuote = tradeDirection === 0 /* BaseToQuote */;
+    const isRateLimiterApplied = checkRateLimiterApplied(
+      baseFeeMode,
+      isBaseToQuote,
+      currentPoint,
+      activationPoint,
+      baseFee.secondFactor
     );
-  }
-  const feeSchedulerMode = baseFee.feeSchedulerMode;
-  if (feeSchedulerMode === 0 /* Linear */) {
-    const reduction = SafeMath.mul(new BN9(period), baseFee.reductionFactor);
-    if (reduction.gt(baseFee.cliffFeeNumerator)) {
-      return new BN9(0);
+    if (currentPoint.lt(activationPoint)) {
+      return baseFee.cliffFeeNumerator;
+    }
+    const lastEffectivePoint = activationPoint.add(maxLimiterDuration);
+    if (currentPoint.gt(lastEffectivePoint)) {
+      return baseFee.cliffFeeNumerator;
+    }
+    if (!inputAmount) {
+      return baseFee.cliffFeeNumerator;
+    }
+    if (isRateLimiterApplied) {
+      return getFeeNumeratorOnRateLimiter(
+        baseFee.cliffFeeNumerator,
+        referenceAmount,
+        new BN11(feeIncrementBps),
+        inputAmount
+      );
+    } else {
+      return baseFee.cliffFeeNumerator;
     }
-    return SafeMath.sub(baseFee.cliffFeeNumerator, reduction);
-  } else if (feeSchedulerMode === 1 /* Exponential */) {
-    return getFeeInPeriod(
-      baseFee.cliffFeeNumerator,
-      baseFee.reductionFactor,
-      period
-    );
   } else {
-    throw new Error("Invalid fee scheduler mode");
+    const numberOfPeriod = baseFee.firstFactor;
+    const periodFrequency = baseFee.secondFactor;
+    const reductionFactor = baseFee.thirdFactor;
+    if (periodFrequency.isZero()) {
+      return baseFee.cliffFeeNumerator;
+    }
+    let period;
+    if (currentPoint.lt(activationPoint)) {
+      period = numberOfPeriod;
+    } else {
+      const elapsedPoints = SafeMath.sub(currentPoint, activationPoint);
+      const periodCount = SafeMath.div(elapsedPoints, periodFrequency);
+      period = Math.min(parseInt(periodCount.toString()), numberOfPeriod);
+    }
+    if (baseFeeMode === 0 /* FeeSchedulerLinear */) {
+      return getFeeNumeratorOnLinearFeeScheduler(
+        baseFee.cliffFeeNumerator,
+        reductionFactor,
+        period
+      );
+    } else {
+      return getFeeNumeratorOnExponentialFeeScheduler(
+        baseFee.cliffFeeNumerator,
+        reductionFactor,
+        period
+      );
+    }
+  }
+}
+function getVariableFee(dynamicFee, volatilityTracker) {
+  if (dynamicFee.initialized === 0) {
+    return new BN11(0);
+  }
+  if (volatilityTracker.volatilityAccumulator.isZero()) {
+    return new BN11(0);
   }
+  const volatilityTimesBinStep = SafeMath.mul(
+    volatilityTracker.volatilityAccumulator,
+    new BN11(dynamicFee.binStep)
+  );
+  const squared = SafeMath.mul(volatilityTimesBinStep, volatilityTimesBinStep);
+  const vFee = SafeMath.mul(squared, new BN11(dynamicFee.variableFeeControl));
+  const scaleFactor = new BN11(1e11);
+  const numerator = SafeMath.add(vFee, SafeMath.sub(scaleFactor, new BN11(1)));
+  return SafeMath.div(numerator, scaleFactor);
 }
-function getFeeOnAmount(amount, poolFees, isReferral, currentPoint, activationPoint, volatilityTracker) {
-  const baseFeeNumerator = getCurrentBaseFeeNumerator(
+function getFeeOnAmount(amount, poolFees, isReferral, currentPoint, activationPoint, volatilityTracker, tradeDirection) {
+  const baseFeeNumerator = getBaseFeeNumerator(
     poolFees.baseFee,
+    tradeDirection,
     currentPoint,
-    activationPoint
+    activationPoint,
+    poolFees.baseFee.baseFeeMode === 2 /* RateLimiter */ ? amount : void 0
   );
   let totalFeeNumerator = baseFeeNumerator;
   if (poolFees.dynamicFee.initialized !== 0) {
@@ -20959,29 +21260,29 @@ function getFeeOnAmount(amount, poolFees, isReferral, currentPoint, activationPo
     );
     totalFeeNumerator = SafeMath.add(totalFeeNumerator, variableFee);
   }
-  if (totalFeeNumerator.gt(new BN9(MAX_FEE_NUMERATOR))) {
-    totalFeeNumerator = new BN9(MAX_FEE_NUMERATOR);
+  if (totalFeeNumerator.gt(new BN11(MAX_FEE_NUMERATOR))) {
+    totalFeeNumerator = new BN11(MAX_FEE_NUMERATOR);
   }
   const tradingFee = mulDiv(
     amount,
     totalFeeNumerator,
-    new BN9(FEE_DENOMINATOR),
+    new BN11(FEE_DENOMINATOR),
     0 /* Up */
   );
   const amountAfterFee = SafeMath.sub(amount, tradingFee);
   const protocolFee = mulDiv(
     tradingFee,
-    new BN9(poolFees.protocolFeePercent),
-    new BN9(100),
+    new BN11(poolFees.protocolFeePercent),
+    new BN11(100),
     1 /* Down */
   );
   const tradingFeeAfterProtocol = SafeMath.sub(tradingFee, protocolFee);
-  let referralFee = new BN9(0);
+  let referralFee = new BN11(0);
   if (isReferral) {
     referralFee = mulDiv(
       protocolFee,
-      new BN9(poolFees.referralFeePercent),
-      new BN9(100),
+      new BN11(poolFees.referralFeePercent),
+      new BN11(100),
       1 /* Down */
     );
   }
@@ -20993,29 +21294,12 @@ function getFeeOnAmount(amount, poolFees, isReferral, currentPoint, activationPo
     referralFee
   };
 }
-function getVariableFee(dynamicFee, volatilityTracker) {
-  if (dynamicFee.initialized === 0) {
-    return new BN9(0);
-  }
-  if (volatilityTracker.volatilityAccumulator.isZero()) {
-    return new BN9(0);
-  }
-  const volatilityTimesBinStep = SafeMath.mul(
-    volatilityTracker.volatilityAccumulator,
-    new BN9(dynamicFee.binStep)
-  );
-  const squared = SafeMath.mul(volatilityTimesBinStep, volatilityTimesBinStep);
-  const vFee = SafeMath.mul(squared, new BN9(dynamicFee.variableFeeControl));
-  const scaleFactor = new BN9(1e11);
-  const numerator = SafeMath.add(vFee, SafeMath.sub(scaleFactor, new BN9(1)));
-  return SafeMath.div(numerator, scaleFactor);
-}
 
 // src/math/swapQuote.ts
 function getSwapResult(poolState, configState, amountIn, feeMode, tradeDirection, currentPoint) {
-  let actualProtocolFee = new BN10(0);
-  let actualTradingFee = new BN10(0);
-  let actualReferralFee = new BN10(0);
+  let actualProtocolFee = new BN12(0);
+  let actualTradingFee = new BN12(0);
+  let actualReferralFee = new BN12(0);
   let actualAmountIn;
   if (feeMode.feesOnInput) {
     const feeResult = getFeeOnAmount(
@@ -21024,7 +21308,8 @@ function getSwapResult(poolState, configState, amountIn, feeMode, tradeDirection
       feeMode.hasReferral,
       currentPoint,
       poolState.activationPoint,
-      poolState.volatilityTracker
+      poolState.volatilityTracker,
+      tradeDirection
     );
     actualProtocolFee = feeResult.protocolFee;
     actualTradingFee = feeResult.tradingFee;
@@ -21052,7 +21337,8 @@ function getSwapResult(poolState, configState, amountIn, feeMode, tradeDirection
       feeMode.hasReferral,
       currentPoint,
       poolState.activationPoint,
-      poolState.volatilityTracker
+      poolState.volatilityTracker,
+      tradeDirection
     );
     actualProtocolFee = feeResult.protocolFee;
     actualTradingFee = feeResult.tradingFee;
@@ -21077,11 +21363,11 @@ function getSwapResult(poolState, configState, amountIn, feeMode, tradeDirection
 function getSwapAmountFromBaseToQuote(configState, currentSqrtPrice, amountIn) {
   if (amountIn.isZero()) {
     return {
-      outputAmount: new BN10(0),
+      outputAmount: new BN12(0),
       nextSqrtPrice: currentSqrtPrice
     };
   }
-  let totalOutputAmount = new BN10(0);
+  let totalOutputAmount = new BN12(0);
   let sqrtPrice = currentSqrtPrice;
   let amountLeft = amountIn;
   for (let i = configState.curve.length - 1; i >= 0; i--) {
@@ -21115,7 +21401,7 @@ function getSwapAmountFromBaseToQuote(configState, currentSqrtPrice, amountIn) {
           outputAmount
         );
         sqrtPrice = nextSqrtPrice;
-        amountLeft = new BN10(0);
+        amountLeft = new BN12(0);
         break;
       } else {
         const nextSqrtPrice = configState.curve[i].sqrtPrice;
@@ -21158,11 +21444,11 @@ function getSwapAmountFromBaseToQuote(configState, currentSqrtPrice, amountIn) {
 function getSwapAmountFromQuoteToBase(configState, currentSqrtPrice, amountIn) {
   if (amountIn.isZero()) {
     return {
-      outputAmount: new BN10(0),
+      outputAmount: new BN12(0),
       nextSqrtPrice: currentSqrtPrice
     };
   }
-  let totalOutputAmount = new BN10(0);
+  let totalOutputAmount = new BN12(0);
   let sqrtPrice = currentSqrtPrice;
   let amountLeft = amountIn;
   for (let i = 0; i < configState.curve.length; i++) {
@@ -21195,7 +21481,7 @@ function getSwapAmountFromQuoteToBase(configState, currentSqrtPrice, amountIn) {
           outputAmount
         );
         sqrtPrice = nextSqrtPrice;
-        amountLeft = new BN10(0);
+        amountLeft = new BN12(0);
         break;
       } else {
         const nextSqrtPrice = configState.curve[i].sqrtPrice;
@@ -21254,8 +21540,8 @@ async function swapQuote(virtualPool, config, swapBaseForQuote, amountIn, slippa
     currentPoint
   );
   if (slippageBps > 0) {
-    const slippageFactor = new BN10(1e4 - slippageBps);
-    const denominator = new BN10(1e4);
+    const slippageFactor = new BN12(1e4 - slippageBps);
+    const denominator = new BN12(1e4);
     const minimumAmountOut = result.amountOut.mul(slippageFactor).div(denominator);
     return {
       ...result,
@@ -21264,6 +21550,40 @@ async function swapQuote(virtualPool, config, swapBaseForQuote, amountIn, slippa
   }
   return result;
 }
+function calculateQuoteExactInAmount(config, virtualPool, currentPoint) {
+  if (virtualPool.quoteReserve.gte(config.migrationQuoteThreshold)) {
+    return new BN12(0);
+  }
+  const amountInAfterFee = config.migrationQuoteThreshold.sub(
+    virtualPool.quoteReserve
+  );
+  if (config.collectFeeMode === 0 /* OnlyQuote */) {
+    const baseFeeNumerator = getBaseFeeNumerator(
+      config.poolFees.baseFee,
+      1 /* QuoteToBase */,
+      currentPoint,
+      virtualPool.activationPoint
+    );
+    let totalFeeNumerator = baseFeeNumerator;
+    if (config.poolFees.dynamicFee.initialized !== 0) {
+      const variableFee = getVariableFee(
+        config.poolFees.dynamicFee,
+        virtualPool.volatilityTracker
+      );
+      totalFeeNumerator = SafeMath.add(totalFeeNumerator, variableFee);
+    }
+    totalFeeNumerator = BN12.min(totalFeeNumerator, new BN12(MAX_FEE_NUMERATOR));
+    const denominator = new BN12(FEE_DENOMINATOR).sub(totalFeeNumerator);
+    return mulDiv(
+      amountInAfterFee,
+      new BN12(FEE_DENOMINATOR),
+      denominator,
+      0 /* Up */
+    );
+  } else {
+    return amountInAfterFee;
+  }
+}
 
 // src/services/state.ts
 import { PublicKey as PublicKey8 } from "@solana/web3.js";
@@ -21508,6 +21828,7 @@ var StateService = class extends DynamicBondingCurveProgram {
 };
 
 // src/services/pool.ts
+import BN13 from "bn.js";
 var PoolService = class extends DynamicBondingCurveProgram {
   constructor(connection, commitment) {
     super(connection, commitment);
@@ -21682,6 +22003,22 @@ var PoolService = class extends DynamicBondingCurveProgram {
     const { baseMint, poolCreator } = createConfigAndPoolWithFirstBuyParam.createPoolParam;
     const { buyAmount, minimumAmountOut, referralTokenAccount } = createConfigAndPoolWithFirstBuyParam.swapBuyParam;
     validateSwapAmount(buyAmount);
+    let currentPoint;
+    if (createConfigAndPoolWithFirstBuyParam.activationType === 0 /* Slot */) {
+      const currentSlot = await this.connection.getSlot();
+      currentPoint = currentSlot;
+    } else {
+      const currentSlot = await this.connection.getSlot();
+      const currentTime = await this.connection.getBlockTime(currentSlot);
+      currentPoint = currentTime;
+    }
+    const isRateLimiterApplied = checkRateLimiterApplied(
+      createConfigAndPoolWithFirstBuyParam.poolFees.baseFee.baseFeeMode,
+      false,
+      new BN13(0),
+      new BN13(0),
+      new BN13(0)
+    );
     const quoteTokenFlag = await getTokenType(this.connection, quoteMint);
     const { inputMint, outputMint, inputTokenProgram, outputTokenProgram } = this.prepareSwapParams(
       false,
@@ -21725,6 +22062,13 @@ var PoolService = class extends DynamicBondingCurveProgram {
       const unwrapIx = unwrapSOLInstruction(poolCreator, poolCreator);
       unwrapIx && postInstructions.push(unwrapIx);
     }
+    const remainingAccounts = isRateLimiterApplied ? [
+      {
+        isSigner: false,
+        isWritable: false,
+        pubkey: SYSVAR_INSTRUCTIONS_PUBKEY
+      }
+    ] : [];
     return this.program.methods.swap({
       amountIn: buyAmount,
       minimumAmountOut
@@ -21742,7 +22086,7 @@ var PoolService = class extends DynamicBondingCurveProgram {
       payer: poolCreator,
       tokenBaseProgram: outputTokenProgram,
       tokenQuoteProgram: inputTokenProgram
-    }).preInstructions(preInstructions).postInstructions(postInstructions).transaction();
+    }).remainingAccounts(remainingAccounts).preInstructions(preInstructions).postInstructions(postInstructions).transaction();
   }
   /**
    * Create a new pool
@@ -21915,6 +22259,22 @@ var PoolService = class extends DynamicBondingCurveProgram {
       tx = await this.initializeToken2022Pool(baseParams);
     }
     validateSwapAmount(buyAmount);
+    let currentPoint;
+    if (poolConfigState.activationType === 0 /* Slot */) {
+      const currentSlot = await this.connection.getSlot();
+      currentPoint = new BN13(currentSlot);
+    } else {
+      const currentSlot = await this.connection.getSlot();
+      const currentTime = await this.connection.getBlockTime(currentSlot);
+      currentPoint = new BN13(currentTime);
+    }
+    const isRateLimiterApplied = checkRateLimiterApplied(
+      poolConfigState.poolFees.baseFee.baseFeeMode,
+      false,
+      new BN13(0),
+      new BN13(0),
+      new BN13(0)
+    );
     const { inputMint, outputMint, inputTokenProgram, outputTokenProgram } = this.prepareSwapParams(
       false,
       { baseMint, poolType: tokenType },
@@ -21948,7 +22308,14 @@ var PoolService = class extends DynamicBondingCurveProgram {
       const unwrapIx = unwrapSOLInstruction(poolCreator, poolCreator);
       unwrapIx && postInstructions.push(unwrapIx);
     }
-    const swapTx = await this.program.methods.swap({
+    const remainingAccounts = isRateLimiterApplied ? [
+      {
+        isSigner: false,
+        isWritable: false,
+        pubkey: SYSVAR_INSTRUCTIONS_PUBKEY
+      }
+    ] : [];
+    const firstBuyTx = await this.program.methods.swap({
       amountIn: buyAmount,
       minimumAmountOut
     }).accountsPartial({
@@ -21965,8 +22332,8 @@ var PoolService = class extends DynamicBondingCurveProgram {
       payer: poolCreator,
       tokenBaseProgram: outputTokenProgram,
       tokenQuoteProgram: inputTokenProgram
-    }).preInstructions(preInstructions).postInstructions(postInstructions).transaction();
-    tx.add(...swapTx.instructions);
+    }).remainingAccounts(remainingAccounts).preInstructions(preInstructions).postInstructions(postInstructions).transaction();
+    tx.add(...firstBuyTx.instructions);
     return tx;
   }
   /**
@@ -21983,6 +22350,22 @@ var PoolService = class extends DynamicBondingCurveProgram {
     const poolConfigState = await this.state.getPoolConfig(poolState.config);
     const { amountIn, minimumAmountOut, swapBaseForQuote, owner } = swapParam;
     validateSwapAmount(amountIn);
+    let currentPoint;
+    if (poolConfigState.activationType === 0 /* Slot */) {
+      const currentSlot = await this.connection.getSlot();
+      currentPoint = new BN13(currentSlot);
+    } else {
+      const currentSlot = await this.connection.getSlot();
+      const currentTime = await this.connection.getBlockTime(currentSlot);
+      currentPoint = new BN13(currentTime);
+    }
+    const isRateLimiterApplied = checkRateLimiterApplied(
+      poolConfigState.poolFees.baseFee.baseFeeMode,
+      swapBaseForQuote,
+      currentPoint,
+      poolState.activationPoint,
+      poolConfigState.poolFees.baseFee.secondFactor
+    );
     const { inputMint, outputMint, inputTokenProgram, outputTokenProgram } = this.prepareSwapParams(swapBaseForQuote, poolState, poolConfigState);
     const {
       ataTokenA: inputTokenAccount,
@@ -22012,6 +22395,13 @@ var PoolService = class extends DynamicBondingCurveProgram {
       const unwrapIx = unwrapSOLInstruction(owner, owner);
       unwrapIx && postInstructions.push(unwrapIx);
     }
+    const remainingAccounts = isRateLimiterApplied ? [
+      {
+        isSigner: false,
+        isWritable: false,
+        pubkey: SYSVAR_INSTRUCTIONS_PUBKEY
+      }
+    ] : [];
     return this.program.methods.swap({
       amountIn,
       minimumAmountOut
@@ -22029,7 +22419,7 @@ var PoolService = class extends DynamicBondingCurveProgram {
       payer: owner,
       tokenBaseProgram: swapBaseForQuote ? inputTokenProgram : outputTokenProgram,
       tokenQuoteProgram: swapBaseForQuote ? outputTokenProgram : inputTokenProgram
-    }).preInstructions(preInstructions).postInstructions(postInstructions).transaction();
+    }).remainingAccounts(remainingAccounts).preInstructions(preInstructions).postInstructions(postInstructions).transaction();
   }
   /**
    * Calculate the amount out for a swap (quote)
@@ -22062,6 +22452,17 @@ var PoolService = class extends DynamicBondingCurveProgram {
       currentPoint
     );
   }
+  swapQuoteExactIn(swapQuoteExactInParam) {
+    const { virtualPool, config, currentPoint } = swapQuoteExactInParam;
+    const requiredQuoteAmount = calculateQuoteExactInAmount(
+      config,
+      virtualPool,
+      currentPoint
+    );
+    return {
+      exactAmountIn: requiredQuoteAmount
+    };
+  }
 };
 
 // src/services/migration.ts
@@ -23478,6 +23879,7 @@ export {
   BASIS_POINT_MAX,
   BIN_STEP_BPS_DEFAULT,
   BIN_STEP_BPS_U128_DEFAULT,
+  BaseFeeMode,
   CollectFeeMode,
   CreatorService,
   DAMM_V1_MIGRATION_FEE_ADDRESS,
@@ -23491,15 +23893,19 @@ export {
   DynamicBondingCurveClient,
   DynamicBondingCurveProgram,
   FEE_DENOMINATOR,
-  FeeSchedulerMode,
   GetFeeMode,
   LOCKER_PROGRAM_ID,
   MAX_CURVE_POINT,
+  MAX_FEE_BPS,
   MAX_FEE_NUMERATOR,
   MAX_PRICE_CHANGE_BPS_DEFAULT,
+  MAX_RATE_LIMITER_DURATION_IN_SECONDS,
+  MAX_RATE_LIMITER_DURATION_IN_SLOTS,
   MAX_SQRT_PRICE,
   MAX_SWALLOW_PERCENTAGE,
   METAPLEX_PROGRAM_ID,
+  MIN_FEE_BPS,
+  MIN_FEE_NUMERATOR,
   MIN_SQRT_PRICE,
   MigrationFeeOption,
   MigrationOption,
@@ -23525,6 +23931,9 @@ export {
   buildCurveWithLiquidityWeights,
   buildCurveWithMarketCap,
   buildCurveWithTwoSegments,
+  calculateFeeSchedulerEndingBaseFeeBps,
+  calculateQuoteExactInAmount,
+  checkRateLimiterApplied,
   cleanUpTokenAccountTx,
   convertDecimalToBN,
   convertToLamports,
@@ -23571,16 +23980,19 @@ export {
   getAccountCreationTimestamp,
   getAccountCreationTimestamps,
   getAccountData,
+  getBaseFeeNumerator,
   getBaseFeeParams,
   getBaseTokenForSwap,
-  getCurrentBaseFeeNumerator,
   getDeltaAmountBase,
   getDeltaAmountBaseUnsigned,
   getDeltaAmountQuoteUnsigned,
   getDynamicFeeParams,
-  getFeeInPeriod,
   getFeeMode,
+  getFeeNumeratorOnExponentialFeeScheduler,
+  getFeeNumeratorOnLinearFeeScheduler,
+  getFeeNumeratorOnRateLimiter,
   getFeeOnAmount,
+  getFeeSchedulerParams,
   getFirstCurve,
   getFirstKey,
   getInitialLiquidityFromDeltaBase,
@@ -23593,13 +24005,13 @@ export {
   getMigrationQuoteAmountFromMigrationQuoteThreshold,
   getMigrationQuoteThresholdFromMigrationQuoteAmount,
   getMigrationThresholdPrice,
-  getMinBaseFeeBps,
   getNextSqrtPriceFromAmountBaseRoundingUp,
   getNextSqrtPriceFromAmountQuoteRoundingDown,
   getNextSqrtPriceFromInput,
   getOrCreateATAInstruction,
   getPercentageSupplyOnMigration,
   getPriceFromSqrtPrice,
+  getRateLimiterParams,
   getSecondKey,
   getSqrtPriceFromMarketCap,
   getSqrtPriceFromPrice,
@@ -23626,6 +24038,8 @@ export {
   validateCollectFeeMode,
   validateConfigParameters,
   validateCurve,
+  validateFeeRateLimiter,
+  validateFeeScheduler,
   validateLPPercentages,
   validateMigrationAndTokenType,
   validateMigrationFeeOption,