@meteora-ag/dynamic-bonding-curve-sdk 1.5.13 → 2.0.0

package/dist/chunk-P4K4GKFH.js

@@ -0,0 +1,2024 @@
+// src/types.ts
+var ActivationType = /* @__PURE__ */ ((ActivationType2) => {
+  ActivationType2[ActivationType2["Slot"] = 0] = "Slot";
+  ActivationType2[ActivationType2["Timestamp"] = 1] = "Timestamp";
+  return ActivationType2;
+})(ActivationType || {});
+var TokenType = /* @__PURE__ */ ((TokenType2) => {
+  TokenType2[TokenType2["SPLToken"] = 0] = "SPLToken";
+  TokenType2[TokenType2["Token2022"] = 1] = "Token2022";
+  return TokenType2;
+})(TokenType || {});
+var CollectFeeMode = /* @__PURE__ */ ((CollectFeeMode2) => {
+  CollectFeeMode2[CollectFeeMode2["QuoteToken"] = 0] = "QuoteToken";
+  CollectFeeMode2[CollectFeeMode2["OutputToken"] = 1] = "OutputToken";
+  return CollectFeeMode2;
+})(CollectFeeMode || {});
+var MigratedCollectFeeMode = /* @__PURE__ */ ((MigratedCollectFeeMode2) => {
+  MigratedCollectFeeMode2[MigratedCollectFeeMode2["QuoteToken"] = 0] = "QuoteToken";
+  MigratedCollectFeeMode2[MigratedCollectFeeMode2["OutputToken"] = 1] = "OutputToken";
+  MigratedCollectFeeMode2[MigratedCollectFeeMode2["Compounding"] = 2] = "Compounding";
+  return MigratedCollectFeeMode2;
+})(MigratedCollectFeeMode || {});
+var DammV2DynamicFeeMode = /* @__PURE__ */ ((DammV2DynamicFeeMode2) => {
+  DammV2DynamicFeeMode2[DammV2DynamicFeeMode2["Disabled"] = 0] = "Disabled";
+  DammV2DynamicFeeMode2[DammV2DynamicFeeMode2["Enabled"] = 1] = "Enabled";
+  return DammV2DynamicFeeMode2;
+})(DammV2DynamicFeeMode || {});
+var DammV2BaseFeeMode = /* @__PURE__ */ ((DammV2BaseFeeMode2) => {
+  DammV2BaseFeeMode2[DammV2BaseFeeMode2["FeeTimeSchedulerLinear"] = 0] = "FeeTimeSchedulerLinear";
+  DammV2BaseFeeMode2[DammV2BaseFeeMode2["FeeTimeSchedulerExponential"] = 1] = "FeeTimeSchedulerExponential";
+  DammV2BaseFeeMode2[DammV2BaseFeeMode2["RateLimiter"] = 2] = "RateLimiter";
+  DammV2BaseFeeMode2[DammV2BaseFeeMode2["FeeMarketCapSchedulerLinear"] = 3] = "FeeMarketCapSchedulerLinear";
+  DammV2BaseFeeMode2[DammV2BaseFeeMode2["FeeMarketCapSchedulerExponential"] = 4] = "FeeMarketCapSchedulerExponential";
+  return DammV2BaseFeeMode2;
+})(DammV2BaseFeeMode || {});
+var MigrationOption = /* @__PURE__ */ ((MigrationOption2) => {
+  MigrationOption2[MigrationOption2["MET_DAMM"] = 0] = "MET_DAMM";
+  MigrationOption2[MigrationOption2["MET_DAMM_V2"] = 1] = "MET_DAMM_V2";
+  return MigrationOption2;
+})(MigrationOption || {});
+var BaseFeeMode = /* @__PURE__ */ ((BaseFeeMode2) => {
+  BaseFeeMode2[BaseFeeMode2["FeeSchedulerLinear"] = 0] = "FeeSchedulerLinear";
+  BaseFeeMode2[BaseFeeMode2["FeeSchedulerExponential"] = 1] = "FeeSchedulerExponential";
+  BaseFeeMode2[BaseFeeMode2["RateLimiter"] = 2] = "RateLimiter";
+  return BaseFeeMode2;
+})(BaseFeeMode || {});
+var MigrationFeeOption = /* @__PURE__ */ ((MigrationFeeOption2) => {
+  MigrationFeeOption2[MigrationFeeOption2["FixedBps25"] = 0] = "FixedBps25";
+  MigrationFeeOption2[MigrationFeeOption2["FixedBps30"] = 1] = "FixedBps30";
+  MigrationFeeOption2[MigrationFeeOption2["FixedBps100"] = 2] = "FixedBps100";
+  MigrationFeeOption2[MigrationFeeOption2["FixedBps200"] = 3] = "FixedBps200";
+  MigrationFeeOption2[MigrationFeeOption2["FixedBps400"] = 4] = "FixedBps400";
+  MigrationFeeOption2[MigrationFeeOption2["FixedBps600"] = 5] = "FixedBps600";
+  MigrationFeeOption2[MigrationFeeOption2["Customizable"] = 6] = "Customizable";
+  return MigrationFeeOption2;
+})(MigrationFeeOption || {});
+var TokenDecimal = /* @__PURE__ */ ((TokenDecimal2) => {
+  TokenDecimal2[TokenDecimal2["SIX"] = 6] = "SIX";
+  TokenDecimal2[TokenDecimal2["SEVEN"] = 7] = "SEVEN";
+  TokenDecimal2[TokenDecimal2["EIGHT"] = 8] = "EIGHT";
+  TokenDecimal2[TokenDecimal2["NINE"] = 9] = "NINE";
+  return TokenDecimal2;
+})(TokenDecimal || {});
+var TradeDirection = /* @__PURE__ */ ((TradeDirection3) => {
+  TradeDirection3[TradeDirection3["BaseToQuote"] = 0] = "BaseToQuote";
+  TradeDirection3[TradeDirection3["QuoteToBase"] = 1] = "QuoteToBase";
+  return TradeDirection3;
+})(TradeDirection || {});
+var Rounding = /* @__PURE__ */ ((Rounding2) => {
+  Rounding2[Rounding2["Up"] = 0] = "Up";
+  Rounding2[Rounding2["Down"] = 1] = "Down";
+  return Rounding2;
+})(Rounding || {});
+var TokenAuthorityOption = /* @__PURE__ */ ((TokenAuthorityOption2) => {
+  TokenAuthorityOption2[TokenAuthorityOption2["CreatorUpdateAuthority"] = 0] = "CreatorUpdateAuthority";
+  TokenAuthorityOption2[TokenAuthorityOption2["Immutable"] = 1] = "Immutable";
+  TokenAuthorityOption2[TokenAuthorityOption2["PartnerUpdateAuthority"] = 2] = "PartnerUpdateAuthority";
+  TokenAuthorityOption2[TokenAuthorityOption2["CreatorUpdateAndMintAuthority"] = 3] = "CreatorUpdateAndMintAuthority";
+  TokenAuthorityOption2[TokenAuthorityOption2["PartnerUpdateAndMintAuthority"] = 4] = "PartnerUpdateAndMintAuthority";
+  return TokenAuthorityOption2;
+})(TokenAuthorityOption || {});
+var SwapMode = /* @__PURE__ */ ((SwapMode2) => {
+  SwapMode2[SwapMode2["ExactIn"] = 0] = "ExactIn";
+  SwapMode2[SwapMode2["PartialFill"] = 1] = "PartialFill";
+  SwapMode2[SwapMode2["ExactOut"] = 2] = "ExactOut";
+  return SwapMode2;
+})(SwapMode || {});
+var TransferFeeWithheldAuthority = /* @__PURE__ */ ((TransferFeeWithheldAuthority2) => {
+  TransferFeeWithheldAuthority2[TransferFeeWithheldAuthority2["Partner"] = 0] = "Partner";
+  TransferFeeWithheldAuthority2[TransferFeeWithheldAuthority2["Creator"] = 1] = "Creator";
+  return TransferFeeWithheldAuthority2;
+})(TransferFeeWithheldAuthority || {});
+var MigratedTransferFeeAuthorityOption = /* @__PURE__ */ ((MigratedTransferFeeAuthorityOption2) => {
+  MigratedTransferFeeAuthorityOption2[MigratedTransferFeeAuthorityOption2["Immutable"] = 0] = "Immutable";
+  MigratedTransferFeeAuthorityOption2[MigratedTransferFeeAuthorityOption2["RevokeZeroFee"] = 1] = "RevokeZeroFee";
+  MigratedTransferFeeAuthorityOption2[MigratedTransferFeeAuthorityOption2["Creator"] = 2] = "Creator";
+  MigratedTransferFeeAuthorityOption2[MigratedTransferFeeAuthorityOption2["Partner"] = 3] = "Partner";
+  return MigratedTransferFeeAuthorityOption2;
+})(MigratedTransferFeeAuthorityOption || {});
+var AccountsType = {
+  TransferHookBase: {
+    transferHookBase: {}
+  },
+  TransferHookBaseReferral: {
+    transferHookBaseReferral: {}
+  }
+};
+
+// src/constants.ts
+import BN from "bn.js";
+import { PublicKey } from "@solana/web3.js";
+var MAX_CURVE_POINT = 16;
+var RESOLUTION = 64;
+var ONE_Q64 = new BN(1).shln(RESOLUTION);
+var FEE_DENOMINATOR = 1e9;
+var MAX_BASIS_POINT = 1e4;
+var MAX_BASE_TRANSFER_FEE_BPS = 1e3;
+var LEGACY_CONFIG_VERSION = 0;
+var U16_MAX = 65535;
+var U24_MAX = 16777215;
+var U64_MAX = new BN("18446744073709551615");
+var U128_MAX = new BN("340282366920938463463374607431768211455");
+var MIN_SQRT_PRICE = new BN("4295048016");
+var MAX_SQRT_PRICE = new BN("79226673521066979257578248091");
+var MIN_FEE_BPS = 25;
+var MAX_FEE_BPS = 9900;
+var MIN_FEE_NUMERATOR = 25e5;
+var MAX_FEE_NUMERATOR = 99e7;
+var MAX_RATE_LIMITER_DURATION_IN_SECONDS = 43200;
+var MAX_RATE_LIMITER_DURATION_IN_SLOTS = 108e3;
+var DYNAMIC_FEE_FILTER_PERIOD_DEFAULT = 10;
+var DYNAMIC_FEE_DECAY_PERIOD_DEFAULT = 120;
+var DYNAMIC_FEE_REDUCTION_FACTOR_DEFAULT = 5e3;
+var DYNAMIC_FEE_SCALING_FACTOR = new BN(1e11);
+var DYNAMIC_FEE_ROUNDING_OFFSET = new BN(99999999999);
+var BIN_STEP_BPS_DEFAULT = 1;
+var BIN_STEP_BPS_U128_DEFAULT = new BN("1844674407370955");
+var MAX_PRICE_CHANGE_BPS_DEFAULT = 1500;
+var MAX_DYNAMIC_FEE_PERCENT = 20;
+var PROTOCOL_FEE_PERCENT = 20;
+var PARTNER_AND_CREATOR_SURPLUS_SHARE = 80;
+var HOST_FEE_PERCENT = 20;
+var SWAP_BUFFER_PERCENTAGE = 25;
+var PROTOCOL_LIQUIDITY_MIGRATION_FEE_BPS = 20;
+var DAMM_V2_COMPOUNDING_DEAD_LIQUIDITY = new BN(100).shln(64);
+var MAX_MIGRATION_FEE_PERCENTAGE = 99;
+var MAX_CREATOR_MIGRATION_FEE_PERCENTAGE = 100;
+var MIN_LOCKED_LIQUIDITY_BPS = 1e3;
+var SECONDS_PER_DAY = 86400;
+var MAX_LOCK_DURATION_IN_SECONDS = 63072e3;
+var PROTOCOL_POOL_CREATION_FEE_PERCENT = 10;
+var MIN_POOL_CREATION_FEE = 1e6;
+var MAX_POOL_CREATION_FEE = 1e11;
+var MIN_MIGRATED_POOL_FEE_BPS = 10;
+var MAX_MIGRATED_POOL_FEE_BPS = 1e3;
+var DYNAMIC_BONDING_CURVE_PROGRAM_ID = new PublicKey(
+  "dbcij3LWUppWqq96dh6gJWwBifmcGfLSB5D4DuSMaqN"
+);
+var METAPLEX_PROGRAM_ID = new PublicKey(
+  "metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s"
+);
+var DAMM_V1_PROGRAM_ID = new PublicKey(
+  "Eo7WjKq67rjJQSZxS6z3YkapzY3eMj6Xy8X5EQVn5UaB"
+);
+var DAMM_V2_PROGRAM_ID = new PublicKey(
+  "cpamdpZCGKUy5JxQXB4dcpGPiikHawvSWAd6mEn1sGG"
+);
+var VAULT_PROGRAM_ID = new PublicKey(
+  "24Uqj9JCLxUeoC3hGfh5W3s9FM9uCHDS2SG3LYwBpyTi"
+);
+var LOCKER_PROGRAM_ID = new PublicKey(
+  "LocpQgucEQHbqNABEYvBvwoxCPsSbG91A1QaQhQQqjn"
+);
+var BASE_ADDRESS = new PublicKey(
+  "HWzXGcGHy4tcpYfaRDCyLNzXqBTv3E6BttpCH2vJxArv"
+);
+var DAMM_V1_MIGRATION_FEE_ADDRESS = [
+  new PublicKey("8f848CEy8eY6PhJ3VcemtBDzPPSD4Vq7aJczLZ3o8MmX"),
+  // FixedBps25
+  new PublicKey("HBxB8Lf14Yj8pqeJ8C4qDb5ryHL7xwpuykz31BLNYr7S"),
+  // FixedBps30
+  new PublicKey("7v5vBdUQHTNeqk1HnduiXcgbvCyVEZ612HLmYkQoAkik"),
+  // FixedBps100
+  new PublicKey("EkvP7d5yKxovj884d2DwmBQbrHUWRLGK6bympzrkXGja"),
+  // FixedBps200
+  new PublicKey("9EZYAJrcqNWNQzP2trzZesP7XKMHA1jEomHzbRsdX8R2"),
+  // FixedBps400
+  new PublicKey("8cdKo87jZU2R12KY1BUjjRPwyjgdNjLGqSGQyrDshhud")
+  // FixedBps600
+];
+var DAMM_V2_MIGRATION_FEE_ADDRESS = [
+  new PublicKey("7F6dnUcRuyM2TwR8myT1dYypFXpPSxqwKNSFNkxyNESd"),
+  // FixedBps25
+  new PublicKey("2nHK1kju6XjphBLbNxpM5XRGFj7p9U8vvNzyZiha1z6k"),
+  // FixedBps30
+  new PublicKey("Hv8Lmzmnju6m7kcokVKvwqz7QPmdX9XfKjJsXz8RXcjp"),
+  // FixedBps100
+  new PublicKey("2c4cYd4reUYVRAB9kUUkrq55VPyy2FNQ3FDL4o12JXmq"),
+  // FixedBps200
+  new PublicKey("AkmQWebAwFvWk55wBoCr5D62C6VVDTzi84NJuD9H7cFD"),
+  // FixedBps400
+  new PublicKey("DbCRBj8McvPYHJG1ukj8RE15h2dCNUdTAESG49XpQ44u"),
+  // FixedBps600
+  new PublicKey("A8gMrEPJkacWkcb3DGwtJwTe16HktSEfvwtuDh2MCtck")
+  // Customizable
+];
+var DEFAULT_MIGRATED_POOL_FEE_PARAMS = {
+  collectFeeMode: 0,
+  dynamicFee: 0,
+  poolFeeBps: 0
+};
+var DEFAULT_LIQUIDITY_VESTING_INFO_PARAMS = {
+  vestingPercentage: 0,
+  bpsPerPeriod: 0,
+  numberOfPeriods: 0,
+  cliffDurationFromMigrationTime: 0,
+  totalDuration: 0
+};
+var DEFAULT_MIGRATED_POOL_MARKET_CAP_FEE_SCHEDULER_PARAMS = {
+  numberOfPeriod: 0,
+  sqrtPriceStepBps: 0,
+  schedulerExpirationDuration: 0,
+  reductionFactor: new BN(0)
+};
+
+// src/math/errors.ts
+var ProgramError = {
+  MathOverflow: "Math operation overflow",
+  ExceededSlippage: "Exceeded slippage tolerance",
+  ExceedMaxFeeBps: "Exceeded max fee bps",
+  AmountIsZero: "Amount is zero",
+  TypeCastFailed: "Type cast error",
+  InvalidActivationType: "Invalid activation type",
+  InvalidQuoteMint: "Invalid quote mint",
+  InvalidCollectFeeMode: "Invalid collect fee mode",
+  InvalidMigrationFeeOption: "Invalid migration fee option",
+  InvalidInput: "Invalid input",
+  NotEnoughLiquidity: "Not enough liquidity",
+  PoolIsCompleted: "Pool is completed",
+  InvalidMigrationOption: "Invalid migration option",
+  InvalidTokenDecimals: "Invalid token decimals",
+  InvalidTokenType: "Invalid token type",
+  InvalidQuoteThreshold: "Invalid quote threshold",
+  InvalidTokenSupply: "Invalid token supply",
+  InvalidCurve: "Invalid curve",
+  InvalidVestingParameters: "Invalid vesting parameters",
+  InsufficientLiquidity: "Liquidity in bonding curve is insufficient",
+  InvalidFeeScheduler: "Invalid fee scheduler",
+  InvalidCreatorTradingFeePercentage: "Invalid creator trading fee percentage",
+  InvalidBaseFeeMode: "Invalid base fee mode",
+  InvalidFeeRateLimiter: "Invalid fee rate limiter",
+  InvalidMigratedPoolFee: "Invalid migrated pool fee params",
+  // the program spells this "Undertermined error"
+  UndeterminedError: "Undetermined error",
+  AmountLeftIsNotZero: "Amount left is not zero",
+  InvalidPoolCreationFee: "Invalid pool creation fee",
+  InvalidFeeMarketCapScheduler: "Invalid fee market cap scheduler",
+  DeprecatedBaseFeeMode: "Deprecated base fee mode",
+  QuoteMintHasNonZeroTransferFee: "Quote mint has a non zero transfer fee or a live transfer fee config authority",
+  DeprecatedMigrationOption: "Deprecated migration option",
+  FeeInverseIsIncorrect: "Transfer fee inverse calculation is incorrect",
+  InvalidTransferFeeParameters: "Invalid transfer fee parameters",
+  ExceededInputAmount: "Required input amount exceeds the provided amount in",
+  InvalidFeeClaimer: "Invalid fee claimer"
+};
+
+// src/math/safeMath.ts
+import BN2 from "bn.js";
+var SafeMath = class {
+  static add(a, b) {
+    return a.add(b);
+  }
+  static sub(a, b) {
+    if (b.gt(a)) {
+      throw new Error(ProgramError.MathOverflow);
+    }
+    return a.sub(b);
+  }
+  static mul(a, b) {
+    return a.mul(b);
+  }
+  static div(a, b) {
+    if (b.isZero()) {
+      throw new Error(ProgramError.MathOverflow);
+    }
+    return a.div(b);
+  }
+  static shl(a, b) {
+    return a.shln(b);
+  }
+  static shr(a, b) {
+    return a.shrn(b);
+  }
+};
+var MAX_EXPONENTIAL = 524288;
+var I32_MIN = new BN2("-2147483648");
+function mulQ64(left, right) {
+  const product = left.mul(right);
+  if (product.gt(U128_MAX)) {
+    throw new Error(ProgramError.MathOverflow);
+  }
+  return product.shrn(RESOLUTION);
+}
+function pow(base, exponent, scaling = true) {
+  const one = new BN2(1).shln(RESOLUTION);
+  if (exponent.eq(I32_MIN) || base.isNeg() || base.gt(U128_MAX)) {
+    throw new Error(ProgramError.MathOverflow);
+  }
+  if (exponent.isZero()) {
+    return one;
+  }
+  let invert = exponent.isNeg();
+  const exp = invert ? exponent.neg() : exponent;
+  if (exp.gte(new BN2(MAX_EXPONENTIAL))) {
+    throw new Error(ProgramError.MathOverflow);
+  }
+  let squaredBase = base;
+  let result = one;
+  if (squaredBase.gte(result)) {
+    squaredBase = U128_MAX.div(squaredBase);
+    invert = !invert;
+  }
+  let remaining = exp;
+  while (!remaining.isZero()) {
+    if (remaining.isOdd()) {
+      result = mulQ64(result, squaredBase);
+    }
+    squaredBase = mulQ64(squaredBase, squaredBase);
+    remaining = remaining.shrn(1);
+  }
+  if (result.isZero()) {
+    throw new Error(ProgramError.MathOverflow);
+  }
+  if (invert) {
+    result = U128_MAX.div(result);
+  }
+  return scaling ? result : result.shrn(RESOLUTION);
+}
+
+// src/math/utilsMath.ts
+import BN3 from "bn.js";
+function mulDiv(x, y, denominator, rounding) {
+  if (denominator.isZero()) {
+    throw new Error(ProgramError.MathOverflow);
+  }
+  const prod = x.mul(y);
+  if (rounding === 0 /* Up */) {
+    return prod.add(denominator.subn(1)).div(denominator);
+  }
+  return prod.div(denominator);
+}
+function toNumerator(bps, feeDenominator) {
+  return mulDiv(bps, feeDenominator, new BN3(MAX_BASIS_POINT), 1 /* Down */);
+}
+function sqrt(value) {
+  if (value.lten(1)) {
+    return value;
+  }
+  let x = value;
+  let y = value.addn(1).divn(2);
+  while (y.lt(x)) {
+    x = y;
+    y = x.add(value.div(x)).divn(2);
+  }
+  return x;
+}
+
+// src/math/curve.ts
+import BN4 from "bn.js";
+function requireU64(value) {
+  if (value.gt(U64_MAX)) {
+    throw new Error(ProgramError.MathOverflow);
+  }
+  return value;
+}
+function requireU128(value) {
+  if (value.gt(U128_MAX)) {
+    throw new Error(ProgramError.MathOverflow);
+  }
+  return value;
+}
+function getInitialLiquidityFromDeltaQuote(quoteAmount, sqrtMinPrice, sqrtPrice) {
+  const priceDelta = SafeMath.sub(sqrtPrice, sqrtMinPrice);
+  return requireU128(SafeMath.div(SafeMath.shl(quoteAmount, 128), priceDelta));
+}
+function getInitialLiquidityFromDeltaBase(baseAmount, sqrtMaxPrice, sqrtPrice) {
+  const priceDelta = SafeMath.sub(sqrtMaxPrice, sqrtPrice);
+  const prod = SafeMath.mul(SafeMath.mul(baseAmount, sqrtPrice), sqrtMaxPrice);
+  return SafeMath.div(prod, priceDelta);
+}
+function getDeltaAmountBaseUnsigned(lowerSqrtPrice, upperSqrtPrice, liquidity, round) {
+  return requireU64(
+    getDeltaAmountBaseUnsigned256(
+      lowerSqrtPrice,
+      upperSqrtPrice,
+      liquidity,
+      round
+    )
+  );
+}
+function getDeltaAmountBaseUnsigned256(lowerSqrtPrice, upperSqrtPrice, liquidity, round) {
+  const numerator = SafeMath.sub(upperSqrtPrice, lowerSqrtPrice);
+  const denominator = SafeMath.mul(lowerSqrtPrice, upperSqrtPrice);
+  return mulDiv(liquidity, numerator, denominator, round);
+}
+function getDeltaAmountQuoteUnsigned(lowerSqrtPrice, upperSqrtPrice, liquidity, round) {
+  return requireU64(
+    getDeltaAmountQuoteUnsigned256(
+      lowerSqrtPrice,
+      upperSqrtPrice,
+      liquidity,
+      round
+    )
+  );
+}
+function getDeltaAmountQuoteUnsigned256(lowerSqrtPrice, upperSqrtPrice, liquidity, round) {
+  const prod = SafeMath.mul(
+    liquidity,
+    SafeMath.sub(upperSqrtPrice, lowerSqrtPrice)
+  );
+  if (round === 0 /* Up */) {
+    const denominator = new BN4(1).shln(RESOLUTION * 2);
+    return SafeMath.div(
+      SafeMath.add(prod, denominator.subn(1)),
+      denominator
+    );
+  }
+  return SafeMath.shr(prod, RESOLUTION * 2);
+}
+function requireSwapInputs(sqrtPrice, liquidity, amount) {
+  requireU128(sqrtPrice);
+  requireU128(liquidity);
+  requireU64(amount);
+  if (sqrtPrice.isZero()) {
+    throw new Error("sqrt_price must be greater than 0");
+  }
+  if (liquidity.isZero()) {
+    throw new Error("liquidity must be greater than 0");
+  }
+}
+function getNextSqrtPriceFromInput(sqrtPrice, liquidity, amountIn, baseForQuote) {
+  requireSwapInputs(sqrtPrice, liquidity, amountIn);
+  return baseForQuote ? getNextSqrtPriceFromBaseAmountInRoundingUp(
+    sqrtPrice,
+    liquidity,
+    amountIn
+  ) : getNextSqrtPriceFromQuoteAmountInRoundingDown(
+    sqrtPrice,
+    liquidity,
+    amountIn
+  );
+}
+function getNextSqrtPriceFromOutput(sqrtPrice, liquidity, amountOut, baseForQuote) {
+  requireSwapInputs(sqrtPrice, liquidity, amountOut);
+  return baseForQuote ? getNextSqrtPriceFromQuoteAmountOutRoundingDown(
+    sqrtPrice,
+    liquidity,
+    amountOut
+  ) : getNextSqrtPriceFromBaseAmountOutRoundingUp(
+    sqrtPrice,
+    liquidity,
+    amountOut
+  );
+}
+function getNextSqrtPriceFromQuoteAmountOutRoundingDown(sqrtPrice, liquidity, amount) {
+  const qAmount = SafeMath.shl(amount, 128);
+  const quotient = SafeMath.div(
+    SafeMath.add(qAmount, SafeMath.sub(liquidity, new BN4(1))),
+    liquidity
+  );
+  return requireU128(SafeMath.sub(sqrtPrice, quotient));
+}
+function getNextSqrtPriceFromBaseAmountOutRoundingUp(sqrtPrice, liquidity, amount) {
+  if (amount.isZero()) {
+    return sqrtPrice;
+  }
+  const denominator = SafeMath.sub(liquidity, SafeMath.mul(amount, sqrtPrice));
+  if (denominator.isZero()) {
+    throw new Error(ProgramError.TypeCastFailed);
+  }
+  return requireU128(mulDiv(liquidity, sqrtPrice, denominator, 0 /* Up */));
+}
+function getNextSqrtPriceFromBaseAmountInRoundingUp(sqrtPrice, liquidity, amount) {
+  if (amount.isZero()) {
+    return sqrtPrice;
+  }
+  const denominator = SafeMath.add(liquidity, SafeMath.mul(amount, sqrtPrice));
+  return requireU128(mulDiv(liquidity, sqrtPrice, denominator, 0 /* Up */));
+}
+function getNextSqrtPriceFromQuoteAmountInRoundingDown(sqrtPrice, liquidity, amount) {
+  const quotient = SafeMath.div(
+    SafeMath.shl(amount, RESOLUTION * 2),
+    liquidity
+  );
+  return requireU128(SafeMath.add(sqrtPrice, quotient));
+}
+function liveCurve(curve) {
+  const end = curve.findIndex(
+    (point) => point.sqrtPrice.isZero() || point.liquidity.isZero()
+  );
+  return end === -1 ? curve : curve.slice(0, end);
+}
+
+// src/math/transferFee.ts
+import {
+  calculateFee,
+  getEpochFee,
+  getTransferFeeConfig,
+  MAX_FEE_BASIS_POINTS
+} from "@solana/spl-token";
+import BN5 from "bn.js";
+var ZERO = new BN5(0);
+function toSplTransferFee(transferFee) {
+  return {
+    epoch: BigInt(0),
+    maximumFee: BigInt(transferFee.maximumFee.toString()),
+    transferFeeBasisPoints: transferFee.transferFeeBasisPoints
+  };
+}
+function isZeroTransferFee(transferFee) {
+  if (!transferFee || transferFee.transferFeeBasisPoints === 0) {
+    return true;
+  }
+  const maximumFee = transferFee.maximumFee;
+  return typeof maximumFee === "bigint" ? maximumFee === BigInt(0) : maximumFee.isZero();
+}
+function getBaseTransferFee(transferFeeBasisPoints) {
+  if (!transferFeeBasisPoints) {
+    return null;
+  }
+  return {
+    transferFeeBasisPoints,
+    maximumFee: U64_MAX
+  };
+}
+function getConfigBaseTransferFee(config) {
+  if (config.transferFeeFlag !== 1) {
+    return null;
+  }
+  return {
+    transferFeeBasisPoints: config.transferFeeBasisPoints,
+    maximumFee: U64_MAX
+  };
+}
+function getEpochTransferFee(mint, currentEpoch) {
+  const transferFeeConfig = getTransferFeeConfig(mint);
+  if (!transferFeeConfig) {
+    return null;
+  }
+  const epochFee = getEpochFee(transferFeeConfig, BigInt(currentEpoch));
+  return {
+    transferFeeBasisPoints: epochFee.transferFeeBasisPoints,
+    maximumFee: new BN5(epochFee.maximumFee.toString())
+  };
+}
+function resolveSwapTransferFees(config, swapBaseForQuote, transferFees) {
+  let base;
+  if (transferFees?.baseMint) {
+    if (transferFees.currentEpoch === void 0) {
+      throw new Error("currentEpoch is required to quote a transfer fee");
+    }
+    base = getEpochTransferFee(
+      transferFees.baseMint,
+      transferFees.currentEpoch
+    );
+  } else if (transferFees?.baseTransferFeeBasisPoints !== void 0) {
+    base = getBaseTransferFee(transferFees.baseTransferFeeBasisPoints);
+  } else {
+    base = getConfigBaseTransferFee(config);
+  }
+  let quote = null;
+  if (transferFees?.quoteMint) {
+    if (config.quoteMint && !transferFees.quoteMint.address.equals(config.quoteMint)) {
+      throw new Error("quoteMint does not match config.quoteMint");
+    }
+    if (transferFees.currentEpoch === void 0) {
+      throw new Error("currentEpoch is required to quote a transfer fee");
+    }
+    quote = getEpochTransferFee(
+      transferFees.quoteMint,
+      transferFees.currentEpoch
+    );
+  } else if (config.quoteTokenFlag === 1 /* Token2022 */) {
+    throw new Error(
+      "quoteMint and currentEpoch are required for a Token-2022 quote mint, use getSwapQuoteTransferFees"
+    );
+  }
+  return swapBaseForQuote ? { input: base, output: quote } : { input: quote, output: base };
+}
+function calculateTransferFeeExcludedAmount(transferFee, includedAmount) {
+  if (!transferFee || isZeroTransferFee(transferFee) || includedAmount.isZero()) {
+    return { amount: includedAmount, transferFee: ZERO };
+  }
+  const fee = new BN5(
+    calculateFee(
+      toSplTransferFee(transferFee),
+      BigInt(includedAmount.toString())
+    ).toString()
+  );
+  return {
+    amount: includedAmount.sub(fee),
+    transferFee: fee
+  };
+}
+function calculatePreFeeAmount(transferFee, excludedAmount) {
+  if (excludedAmount.isZero() || isZeroTransferFee(transferFee)) {
+    return excludedAmount;
+  }
+  if (transferFee.transferFeeBasisPoints === MAX_FEE_BASIS_POINTS) {
+    return excludedAmount.add(transferFee.maximumFee);
+  }
+  const oneInBasisPoints = new BN5(MAX_FEE_BASIS_POINTS);
+  const denominator = oneInBasisPoints.subn(
+    transferFee.transferFeeBasisPoints
+  );
+  const rawPreFeeAmount = excludedAmount.mul(oneInBasisPoints).add(denominator).subn(1).div(denominator);
+  if (rawPreFeeAmount.sub(excludedAmount).gte(transferFee.maximumFee)) {
+    return excludedAmount.add(transferFee.maximumFee);
+  }
+  return rawPreFeeAmount;
+}
+function calculateTransferFeeIncludedAmount(transferFee, excludedAmount) {
+  if (excludedAmount.isZero()) {
+    return { amount: ZERO, transferFee: ZERO };
+  }
+  if (!transferFee || isZeroTransferFee(transferFee)) {
+    return { amount: excludedAmount, transferFee: ZERO };
+  }
+  const preFeeAmount = calculatePreFeeAmount(transferFee, excludedAmount);
+  if (preFeeAmount.gt(U64_MAX)) {
+    throw new Error(ProgramError.MathOverflow);
+  }
+  const fee = calculateTransferFeeExcludedAmount(
+    transferFee,
+    preFeeAmount
+  ).transferFee;
+  const includedAmount = excludedAmount.add(fee);
+  const verification = calculateTransferFeeExcludedAmount(
+    transferFee,
+    includedAmount
+  ).transferFee;
+  if (!fee.eq(verification)) {
+    throw new Error(ProgramError.FeeInverseIsIncorrect);
+  }
+  return { amount: includedAmount, transferFee: fee };
+}
+
+// src/math/poolFees/feeScheduler.ts
+import BN6 from "bn.js";
+function getFeeSchedulerMinBaseFeeNumerator(cliffFeeNumerator, numberOfPeriod, reductionFactor, feeSchedulerMode) {
+  return getBaseFeeNumeratorByPeriod(
+    cliffFeeNumerator,
+    numberOfPeriod,
+    new BN6(numberOfPeriod),
+    reductionFactor,
+    feeSchedulerMode
+  );
+}
+function getBaseFeeNumeratorByPeriod(cliffFeeNumerator, numberOfPeriod, period, reductionFactor, feeSchedulerMode) {
+  const periodNumber = BN6.min(period, new BN6(numberOfPeriod)).toNumber();
+  if (periodNumber > U16_MAX) {
+    throw new Error(ProgramError.MathOverflow);
+  }
+  switch (feeSchedulerMode) {
+    case 0 /* FeeSchedulerLinear */:
+      return getFeeNumeratorOnLinearFeeScheduler(
+        cliffFeeNumerator,
+        reductionFactor,
+        periodNumber
+      );
+    case 1 /* FeeSchedulerExponential */:
+      return getFeeNumeratorOnExponentialFeeScheduler(
+        cliffFeeNumerator,
+        reductionFactor,
+        periodNumber
+      );
+    default:
+      throw new Error(ProgramError.InvalidBaseFeeMode);
+  }
+}
+function getFeeNumeratorOnLinearFeeScheduler(cliffFeeNumerator, reductionFactor, period) {
+  return SafeMath.sub(
+    cliffFeeNumerator,
+    SafeMath.mul(new BN6(period), reductionFactor)
+  );
+}
+function getFeeNumeratorOnExponentialFeeScheduler(cliffFeeNumerator, reductionFactor, period) {
+  if (period === 0) {
+    return cliffFeeNumerator;
+  }
+  const bps = SafeMath.div(
+    SafeMath.shl(reductionFactor, 64),
+    new BN6(MAX_BASIS_POINT)
+  );
+  const base = SafeMath.sub(ONE_Q64, bps);
+  const result = pow(base, new BN6(period));
+  return SafeMath.div(SafeMath.mul(cliffFeeNumerator, result), ONE_Q64);
+}
+function getBaseFeeNumerator(cliffFeeNumerator, numberOfPeriod, periodFrequency, reductionFactor, feeSchedulerMode, currentPoint, activationPoint) {
+  if (periodFrequency.isZero()) {
+    return cliffFeeNumerator;
+  }
+  const period = SafeMath.div(
+    SafeMath.sub(currentPoint, activationPoint),
+    periodFrequency
+  );
+  return getBaseFeeNumeratorByPeriod(
+    cliffFeeNumerator,
+    numberOfPeriod,
+    period,
+    reductionFactor,
+    feeSchedulerMode
+  );
+}
+
+// src/math/feeAmount.ts
+import BN7 from "bn.js";
+function getExcludedFeeAmount(tradeFeeNumerator2, includedFeeAmount) {
+  const tradingFee = mulDiv(
+    includedFeeAmount,
+    tradeFeeNumerator2,
+    new BN7(FEE_DENOMINATOR),
+    0 /* Up */
+  );
+  return [SafeMath.sub(includedFeeAmount, tradingFee), tradingFee];
+}
+function getIncludedFeeAmount(tradeFeeNumerator2, excludedFeeAmount) {
+  const includedFeeAmount = mulDiv(
+    excludedFeeAmount,
+    new BN7(FEE_DENOMINATOR),
+    SafeMath.sub(new BN7(FEE_DENOMINATOR), tradeFeeNumerator2),
+    0 /* Up */
+  );
+  if (includedFeeAmount.gt(U64_MAX)) {
+    throw new Error(ProgramError.TypeCastFailed);
+  }
+  return [
+    includedFeeAmount,
+    SafeMath.sub(includedFeeAmount, excludedFeeAmount)
+  ];
+}
+
+// src/math/poolFees/rateLimiter.ts
+import BN8 from "bn.js";
+function isRateLimiterApplied(currentPoint, activationPoint, tradeDirection, maxLimiterDuration, referenceAmount, feeIncrementBps) {
+  if (isZeroRateLimiter(referenceAmount, maxLimiterDuration, feeIncrementBps)) {
+    return false;
+  }
+  if (tradeDirection === 0 /* BaseToQuote */) {
+    return false;
+  }
+  return currentPoint.lte(activationPoint.add(maxLimiterDuration));
+}
+function isZeroRateLimiter(referenceAmount, maxLimiterDuration, feeIncrementBps) {
+  return referenceAmount.isZero() && maxLimiterDuration.isZero() && feeIncrementBps.isZero();
+}
+function isNonZeroRateLimiter(referenceAmount, maxLimiterDuration, feeIncrementBps) {
+  return !referenceAmount.isZero() && !maxLimiterDuration.isZero() && !feeIncrementBps.isZero();
+}
+function getMaxIndex(cliffFeeNumerator, feeIncrementBps) {
+  const deltaNumerator = SafeMath.sub(
+    new BN8(MAX_FEE_NUMERATOR),
+    cliffFeeNumerator
+  );
+  return SafeMath.div(
+    deltaNumerator,
+    toNumerator(feeIncrementBps, new BN8(FEE_DENOMINATOR))
+  );
+}
+function getCheckedAmounts(cliffFeeNumerator, referenceAmount, feeIncrementBps) {
+  const maxIndex = getMaxIndex(cliffFeeNumerator, feeIncrementBps);
+  const maxIndexInputAmount = maxIndex.addn(1).mul(referenceAmount);
+  const isOverflow = maxIndexInputAmount.gt(U64_MAX);
+  const checkedIncludedFeeAmount = isOverflow ? U64_MAX : maxIndexInputAmount;
+  const checkedExcludedFeeAmount = getRateLimiterExcludedFeeAmount(
+    cliffFeeNumerator,
+    referenceAmount,
+    feeIncrementBps,
+    checkedIncludedFeeAmount
+  );
+  return [checkedExcludedFeeAmount, checkedIncludedFeeAmount, isOverflow];
+}
+function getFeeNumeratorFromExcludedAmount(cliffFeeNumerator, referenceAmount, feeIncrementBps, excludedFeeAmount) {
+  const excludedFeeReferenceAmount = getRateLimiterExcludedFeeAmount(
+    cliffFeeNumerator,
+    referenceAmount,
+    feeIncrementBps,
+    referenceAmount
+  );
+  if (excludedFeeAmount.lte(excludedFeeReferenceAmount)) {
+    return cliffFeeNumerator;
+  }
+  const [checkedExcludedFeeAmount, checkedIncludedFeeAmount, isOverflow] = getCheckedAmounts(cliffFeeNumerator, referenceAmount, feeIncrementBps);
+  if (excludedFeeAmount.eq(checkedExcludedFeeAmount)) {
+    return getFeeNumeratorFromIncludedAmount(
+      cliffFeeNumerator,
+      referenceAmount,
+      feeIncrementBps,
+      checkedIncludedFeeAmount
+    );
+  }
+  let includedFeeAmount;
+  if (excludedFeeAmount.lt(checkedExcludedFeeAmount)) {
+    const two = new BN8(2);
+    const i = toNumerator(feeIncrementBps, new BN8(FEE_DENOMINATOR));
+    const x0 = referenceAmount;
+    const d = new BN8(FEE_DENOMINATOR);
+    const c = cliffFeeNumerator;
+    const y = two.mul(d).mul(x0).add(i.mul(x0)).sub(two.mul(c).mul(x0));
+    const z = two.mul(excludedFeeAmount).mul(d).mul(x0);
+    const discriminant = y.mul(y).sub(new BN8(4).mul(i).mul(z));
+    const wholePeriodsInput = y.sub(sqrt(discriminant)).div(two.mul(i));
+    const aPlusOne = wholePeriodsInput.div(x0);
+    const excludedFeeRemainingAmount = SafeMath.sub(
+      excludedFeeAmount,
+      getRateLimiterExcludedFeeAmount(
+        cliffFeeNumerator,
+        referenceAmount,
+        feeIncrementBps,
+        wholePeriodsInput
+      )
+    );
+    const [includedFeeRemainingAmount] = getIncludedFeeAmount(
+      c.add(i.mul(aPlusOne)),
+      excludedFeeRemainingAmount
+    );
+    includedFeeAmount = wholePeriodsInput.add(includedFeeRemainingAmount);
+  } else {
+    if (isOverflow) {
+      throw new Error(ProgramError.MathOverflow);
+    }
+    const excludedFeeRemainingAmount = SafeMath.sub(
+      excludedFeeAmount,
+      checkedExcludedFeeAmount
+    );
+    const [includedFeeRemainingAmount] = getIncludedFeeAmount(
+      new BN8(MAX_FEE_NUMERATOR),
+      excludedFeeRemainingAmount
+    );
+    includedFeeAmount = checkedIncludedFeeAmount.add(
+      includedFeeRemainingAmount
+    );
+  }
+  const tradingFee = SafeMath.sub(includedFeeAmount, excludedFeeAmount);
+  const feeNumerator = mulDiv(
+    tradingFee,
+    new BN8(FEE_DENOMINATOR),
+    includedFeeAmount,
+    0 /* Up */
+  );
+  if (feeNumerator.lt(cliffFeeNumerator)) {
+    throw new Error(ProgramError.UndeterminedError);
+  }
+  return feeNumerator;
+}
+function getRateLimiterExcludedFeeAmount(cliffFeeNumerator, referenceAmount, feeIncrementBps, includedFeeAmount) {
+  const feeNumerator = getFeeNumeratorFromIncludedAmount(
+    cliffFeeNumerator,
+    referenceAmount,
+    feeIncrementBps,
+    includedFeeAmount
+  );
+  return getExcludedFeeAmount(feeNumerator, includedFeeAmount)[0];
+}
+function getMaxOutAmountWithMinBaseFee(cliffFeeNumerator, referenceAmount, feeIncrementBps) {
+  return getRateLimiterExcludedFeeAmount(
+    cliffFeeNumerator,
+    referenceAmount,
+    feeIncrementBps,
+    referenceAmount
+  );
+}
+function getFeeNumeratorFromIncludedAmount(cliffFeeNumerator, referenceAmount, feeIncrementBps, includedFeeAmount) {
+  if (includedFeeAmount.lte(referenceAmount)) {
+    return cliffFeeNumerator;
+  }
+  const c = cliffFeeNumerator;
+  const diff = includedFeeAmount.sub(referenceAmount);
+  const a = diff.div(referenceAmount);
+  const b = diff.mod(referenceAmount);
+  const maxIndex = getMaxIndex(cliffFeeNumerator, feeIncrementBps);
+  const i = toNumerator(feeIncrementBps, new BN8(FEE_DENOMINATOR));
+  const x0 = referenceAmount;
+  const one = new BN8(1);
+  const two = new BN8(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)));
+    tradingFeeNumerator = x0.mul(numerator1).add(b.mul(numerator2));
+  } else {
+    const numerator1 = c.add(c.mul(maxIndex)).add(i.mul(maxIndex).mul(maxIndex.add(one)).div(two));
+    const leftAmount = a.sub(maxIndex).mul(x0).add(b);
+    tradingFeeNumerator = x0.mul(numerator1).add(leftAmount.mul(new BN8(MAX_FEE_NUMERATOR)));
+  }
+  const denominator = new BN8(FEE_DENOMINATOR);
+  const tradingFee = tradingFeeNumerator.add(denominator).sub(one).div(denominator);
+  return mulDiv(
+    tradingFee,
+    new BN8(FEE_DENOMINATOR),
+    includedFeeAmount,
+    0 /* Up */
+  );
+}
+
+// src/math/poolFees/baseFee.ts
+import BN9 from "bn.js";
+var FeeRateLimiter = class {
+  constructor(cliffFeeNumerator, feeIncrementBps, maxLimiterDuration, referenceAmount) {
+    this.cliffFeeNumerator = cliffFeeNumerator;
+    this.feeIncrementBps = feeIncrementBps;
+    this.maxLimiterDuration = maxLimiterDuration;
+    this.referenceAmount = referenceAmount;
+  }
+  getMinBaseFeeNumerator() {
+    return this.cliffFeeNumerator;
+  }
+  isApplied(currentPoint, activationPoint, tradeDirection) {
+    return isRateLimiterApplied(
+      currentPoint,
+      activationPoint,
+      tradeDirection,
+      this.maxLimiterDuration,
+      this.referenceAmount,
+      new BN9(this.feeIncrementBps)
+    );
+  }
+  getBaseFeeNumeratorFromIncludedFeeAmount(currentPoint, activationPoint, tradeDirection, includedFeeAmount) {
+    if (!this.isApplied(currentPoint, activationPoint, tradeDirection)) {
+      return this.cliffFeeNumerator;
+    }
+    return getFeeNumeratorFromIncludedAmount(
+      this.cliffFeeNumerator,
+      this.referenceAmount,
+      new BN9(this.feeIncrementBps),
+      includedFeeAmount
+    );
+  }
+  getBaseFeeNumeratorFromExcludedFeeAmount(currentPoint, activationPoint, tradeDirection, excludedFeeAmount) {
+    if (!this.isApplied(currentPoint, activationPoint, tradeDirection)) {
+      return this.cliffFeeNumerator;
+    }
+    return getFeeNumeratorFromExcludedAmount(
+      this.cliffFeeNumerator,
+      this.referenceAmount,
+      new BN9(this.feeIncrementBps),
+      excludedFeeAmount
+    );
+  }
+};
+var FeeScheduler = class {
+  constructor(cliffFeeNumerator, numberOfPeriod, periodFrequency, reductionFactor, feeSchedulerMode) {
+    this.cliffFeeNumerator = cliffFeeNumerator;
+    this.numberOfPeriod = numberOfPeriod;
+    this.periodFrequency = periodFrequency;
+    this.reductionFactor = reductionFactor;
+    this.feeSchedulerMode = feeSchedulerMode;
+  }
+  getMinBaseFeeNumerator() {
+    return getFeeSchedulerMinBaseFeeNumerator(
+      this.cliffFeeNumerator,
+      this.numberOfPeriod,
+      this.reductionFactor,
+      this.feeSchedulerMode
+    );
+  }
+  // a scheduler's fee depends on the point, not on the amount
+  getBaseFeeNumeratorFromIncludedFeeAmount(currentPoint, activationPoint) {
+    return getBaseFeeNumerator(
+      this.cliffFeeNumerator,
+      this.numberOfPeriod,
+      this.periodFrequency,
+      this.reductionFactor,
+      this.feeSchedulerMode,
+      currentPoint,
+      activationPoint
+    );
+  }
+  getBaseFeeNumeratorFromExcludedFeeAmount(currentPoint, activationPoint) {
+    return this.getBaseFeeNumeratorFromIncludedFeeAmount(
+      currentPoint,
+      activationPoint
+    );
+  }
+};
+function getBaseFeeHandler(cliffFeeNumerator, firstFactor, secondFactor, thirdFactor, baseFeeMode) {
+  switch (baseFeeMode) {
+    case 0 /* FeeSchedulerLinear */:
+    case 1 /* FeeSchedulerExponential */:
+      return new FeeScheduler(
+        cliffFeeNumerator,
+        firstFactor,
+        secondFactor,
+        thirdFactor,
+        baseFeeMode
+      );
+    case 2 /* RateLimiter */:
+      return new FeeRateLimiter(
+        cliffFeeNumerator,
+        firstFactor,
+        secondFactor,
+        thirdFactor
+      );
+    default:
+      throw new Error(ProgramError.InvalidBaseFeeMode);
+  }
+}
+
+// src/math/poolFees/dynamicFee.ts
+import BN10 from "bn.js";
+function isDynamicFeeEnabled(dynamicFee) {
+  return dynamicFee.initialized !== 0;
+}
+function getVariableFeeNumerator(dynamicFee, volatilityTracker) {
+  if (!isDynamicFeeEnabled(dynamicFee)) {
+    return new BN10(0);
+  }
+  const volatilityTimesBinStep = SafeMath.mul(
+    volatilityTracker.volatilityAccumulator,
+    new BN10(dynamicFee.binStep)
+  );
+  const vFee = SafeMath.mul(
+    SafeMath.mul(volatilityTimesBinStep, volatilityTimesBinStep),
+    new BN10(dynamicFee.variableFeeControl)
+  );
+  return SafeMath.div(
+    SafeMath.add(vFee, DYNAMIC_FEE_ROUNDING_OFFSET),
+    DYNAMIC_FEE_SCALING_FACTOR
+  );
+}
+
+// src/math/feeMath.ts
+import BN11 from "bn.js";
+var FEE_MODES = {
+  [0 /* QuoteToken */]: {
+    [0 /* BaseToQuote */]: [false, false],
+    [1 /* QuoteToBase */]: [true, false]
+  },
+  [1 /* OutputToken */]: {
+    [0 /* BaseToQuote */]: [false, false],
+    [1 /* QuoteToBase */]: [false, true]
+  }
+};
+function getFeeMode(collectFeeMode, tradeDirection, hasReferral) {
+  const mode = FEE_MODES[collectFeeMode]?.[tradeDirection];
+  if (!mode) {
+    throw new Error(ProgramError.InvalidCollectFeeMode);
+  }
+  const [feesOnInput, feesOnBaseToken] = mode;
+  return { feesOnInput, feesOnBaseToken, hasReferral };
+}
+function baseFeeHandlerOf(poolFees) {
+  const { baseFee } = poolFees;
+  return getBaseFeeHandler(
+    baseFee.cliffFeeNumerator,
+    baseFee.firstFactor,
+    baseFee.secondFactor,
+    baseFee.thirdFactor,
+    baseFee.baseFeeMode
+  );
+}
+function getTotalFeeNumeratorFromIncludedFeeAmount(poolFees, volatilityTracker, currentPoint, activationPoint, includedFeeAmount, tradeDirection) {
+  const baseFeeNumerator = baseFeeHandlerOf(
+    poolFees
+  ).getBaseFeeNumeratorFromIncludedFeeAmount(
+    currentPoint,
+    activationPoint,
+    tradeDirection,
+    includedFeeAmount
+  );
+  return getTotalFeeNumerator(
+    baseFeeNumerator,
+    poolFees.dynamicFee,
+    volatilityTracker
+  );
+}
+function getTotalFeeNumeratorFromExcludedFeeAmount(poolFees, volatilityTracker, currentPoint, activationPoint, excludedFeeAmount, tradeDirection) {
+  const baseFeeNumerator = baseFeeHandlerOf(
+    poolFees
+  ).getBaseFeeNumeratorFromExcludedFeeAmount(
+    currentPoint,
+    activationPoint,
+    tradeDirection,
+    excludedFeeAmount
+  );
+  return getTotalFeeNumerator(
+    baseFeeNumerator,
+    poolFees.dynamicFee,
+    volatilityTracker
+  );
+}
+function getTotalFeeNumerator(baseFeeNumerator, dynamicFee, volatilityTracker) {
+  return BN11.min(
+    SafeMath.add(
+      getVariableFeeNumerator(dynamicFee, volatilityTracker),
+      baseFeeNumerator
+    ),
+    new BN11(MAX_FEE_NUMERATOR)
+  );
+}
+function getFeeOnAmount(tradeFeeNumerator2, amount, hasReferral) {
+  const [amountAfterFee, feeAmount] = getExcludedFeeAmount(
+    tradeFeeNumerator2,
+    amount
+  );
+  const [tradingFee, protocolFee, referralFee] = splitFees(
+    feeAmount,
+    hasReferral
+  );
+  return { amount: amountAfterFee, tradingFee, protocolFee, referralFee };
+}
+function splitFees(feeAmount, hasReferral) {
+  const protocolFee = mulDiv(
+    feeAmount,
+    new BN11(PROTOCOL_FEE_PERCENT),
+    new BN11(100),
+    1 /* Down */
+  );
+  const tradingFee = SafeMath.sub(feeAmount, protocolFee);
+  const referralFee = hasReferral ? mulDiv(
+    protocolFee,
+    new BN11(HOST_FEE_PERCENT),
+    new BN11(100),
+    1 /* Down */
+  ) : new BN11(0);
+  return [tradingFee, SafeMath.sub(protocolFee, referralFee), referralFee];
+}
+
+// src/math/swapQuote.ts
+import BN12 from "bn.js";
+var ZERO2 = new BN12(0);
+var NO_FEES = {
+  tradingFee: ZERO2,
+  protocolFee: ZERO2,
+  referralFee: ZERO2
+};
+function addU64(total, amount) {
+  const sum = total.add(amount);
+  if (sum.gt(U64_MAX)) {
+    throw new Error(ProgramError.MathOverflow);
+  }
+  return sum;
+}
+function u64(amount) {
+  if (amount.gt(U64_MAX)) {
+    throw new Error(ProgramError.MathOverflow);
+  }
+  return amount;
+}
+function assertSlippageBps(slippageBps) {
+  if (slippageBps < 0 || slippageBps > MAX_BASIS_POINT) {
+    throw new Error(`slippageBps must be between 0 and ${MAX_BASIS_POINT}`);
+  }
+}
+function minimumAmountOutWithSlippage(amount, slippageBps) {
+  assertSlippageBps(slippageBps);
+  return amount.muln(MAX_BASIS_POINT - slippageBps).divn(MAX_BASIS_POINT);
+}
+function maximumAmountInWithSlippage(amount, slippageBps) {
+  assertSlippageBps(slippageBps);
+  return amount.muln(MAX_BASIS_POINT + slippageBps).divn(MAX_BASIS_POINT);
+}
+function isFirstSwapWithMinFee(virtualPool, config, hasReferral, eligibleForFirstSwapWithMinFee) {
+  return eligibleForFirstSwapWithMinFee && !hasReferral && config.enableFirstSwapWithMinFee === 1 && virtualPool.poolState.hasSwap === 0;
+}
+function beginSwapQuote(virtualPool, config, swapBaseForQuote, amount, hasReferral, transferFees) {
+  if (amount.isZero()) {
+    throw new Error(ProgramError.AmountIsZero);
+  }
+  if (virtualPool.poolState.quoteReserve.gte(config.migrationQuoteThreshold)) {
+    throw new Error(ProgramError.PoolIsCompleted);
+  }
+  const tradeDirection = swapBaseForQuote ? 0 /* BaseToQuote */ : 1 /* QuoteToBase */;
+  return {
+    tradeDirection,
+    feeMode: getFeeMode(config.collectFeeMode, tradeDirection, hasReferral),
+    ...resolveSwapTransferFees(config, swapBaseForQuote, transferFees)
+  };
+}
+function tradeFeeNumerator(virtualPool, config, currentPoint, tradeDirection, amount, amountExcludesFee, eligibleForFirstSwapWithMinFee) {
+  if (eligibleForFirstSwapWithMinFee) {
+    const { baseFee } = config.poolFees;
+    return getBaseFeeHandler(
+      baseFee.cliffFeeNumerator,
+      baseFee.firstFactor,
+      baseFee.secondFactor,
+      baseFee.thirdFactor,
+      baseFee.baseFeeMode
+    ).getMinBaseFeeNumerator();
+  }
+  const totalFeeNumerator = amountExcludesFee ? getTotalFeeNumeratorFromExcludedFeeAmount : getTotalFeeNumeratorFromIncludedFeeAmount;
+  return totalFeeNumerator(
+    config.poolFees,
+    virtualPool.poolState.volatilityTracker,
+    currentPoint,
+    virtualPool.poolState.activationPoint,
+    amount,
+    tradeDirection
+  );
+}
+function takeFee(feeNumerator, includedFeeAmount, hasReferral) {
+  const { amount, ...fees } = getFeeOnAmount(
+    feeNumerator,
+    includedFeeAmount,
+    hasReferral
+  );
+  return { amount, fees };
+}
+function addFee(feeNumerator, excludedFeeAmount, hasReferral) {
+  const [amount, feeAmount] = getIncludedFeeAmount(
+    feeNumerator,
+    excludedFeeAmount
+  );
+  const [tradingFee, protocolFee, referralFee] = splitFees(
+    feeAmount,
+    hasReferral
+  );
+  return { amount, fees: { tradingFee, protocolFee, referralFee } };
+}
+function swapFromInput(virtualPool, config, tradeDirection, amountIn) {
+  return tradeDirection === 0 /* BaseToQuote */ ? calculateBaseToQuoteFromAmountIn(
+    config,
+    virtualPool.poolState.sqrtPrice,
+    amountIn
+  ) : calculateQuoteToBaseFromAmountIn(
+    config,
+    virtualPool.poolState.sqrtPrice,
+    amountIn,
+    config.migrationSqrtPrice
+  );
+}
+function getSwapResultFromExactInput(virtualPool, config, amountIn, feeMode, tradeDirection, currentPoint, eligibleForFirstSwapWithMinFee) {
+  const feeNumerator = tradeFeeNumerator(
+    virtualPool,
+    config,
+    currentPoint,
+    tradeDirection,
+    amountIn,
+    false,
+    eligibleForFirstSwapWithMinFee
+  );
+  let fees = NO_FEES;
+  let actualAmountIn = amountIn;
+  if (feeMode.feesOnInput) {
+    ;
+    ({ amount: actualAmountIn, fees } = takeFee(
+      feeNumerator,
+      amountIn,
+      feeMode.hasReferral
+    ));
+  }
+  const { outputAmount, nextSqrtPrice, amountLeft } = swapFromInput(
+    virtualPool,
+    config,
+    tradeDirection,
+    actualAmountIn
+  );
+  if (!amountLeft.isZero()) {
+    throw new Error(ProgramError.InsufficientLiquidity);
+  }
+  let actualAmountOut = outputAmount;
+  if (!feeMode.feesOnInput) {
+    ;
+    ({ amount: actualAmountOut, fees } = takeFee(
+      feeNumerator,
+      outputAmount,
+      feeMode.hasReferral
+    ));
+  }
+  return {
+    amountLeft,
+    includedFeeInputAmount: amountIn,
+    excludedFeeInputAmount: actualAmountIn,
+    outputAmount: actualAmountOut,
+    nextSqrtPrice,
+    ...fees
+  };
+}
+function getSwapResult(virtualPool, config, amountIn, feeMode, tradeDirection, currentPoint, eligibleForFirstSwapWithMinFee) {
+  const result = getSwapResultFromExactInput(
+    virtualPool,
+    config,
+    amountIn,
+    feeMode,
+    tradeDirection,
+    currentPoint,
+    eligibleForFirstSwapWithMinFee
+  );
+  return {
+    actualInputAmount: result.excludedFeeInputAmount,
+    outputAmount: result.outputAmount,
+    nextSqrtPrice: result.nextSqrtPrice,
+    tradingFee: result.tradingFee,
+    protocolFee: result.protocolFee,
+    referralFee: result.referralFee
+  };
+}
+function getSwapResultFromPartialInput(virtualPool, config, amountIn, feeMode, tradeDirection, currentPoint, eligibleForFirstSwapWithMinFee) {
+  const feeNumerator = tradeFeeNumerator(
+    virtualPool,
+    config,
+    currentPoint,
+    tradeDirection,
+    amountIn,
+    false,
+    eligibleForFirstSwapWithMinFee
+  );
+  let fees = NO_FEES;
+  let actualAmountIn = amountIn;
+  if (feeMode.feesOnInput) {
+    ;
+    ({ amount: actualAmountIn, fees } = takeFee(
+      feeNumerator,
+      amountIn,
+      feeMode.hasReferral
+    ));
+  }
+  const { outputAmount, nextSqrtPrice, amountLeft } = swapFromInput(
+    virtualPool,
+    config,
+    tradeDirection,
+    actualAmountIn
+  );
+  let includedFeeInputAmount = amountIn;
+  if (!amountLeft.isZero()) {
+    actualAmountIn = SafeMath.sub(actualAmountIn, amountLeft);
+    if (feeMode.feesOnInput) {
+      const partialFeeNumerator = tradeFeeNumerator(
+        virtualPool,
+        config,
+        currentPoint,
+        tradeDirection,
+        actualAmountIn,
+        true,
+        eligibleForFirstSwapWithMinFee
+      );
+      ({ amount: includedFeeInputAmount, fees } = addFee(
+        partialFeeNumerator,
+        actualAmountIn,
+        feeMode.hasReferral
+      ));
+    } else {
+      includedFeeInputAmount = actualAmountIn;
+    }
+  }
+  let actualAmountOut = outputAmount;
+  if (!feeMode.feesOnInput) {
+    ;
+    ({ amount: actualAmountOut, fees } = takeFee(
+      feeNumerator,
+      outputAmount,
+      feeMode.hasReferral
+    ));
+  }
+  return {
+    amountLeft,
+    includedFeeInputAmount,
+    excludedFeeInputAmount: actualAmountIn,
+    outputAmount: actualAmountOut,
+    nextSqrtPrice,
+    ...fees
+  };
+}
+function getSwapResultFromExactOutput(virtualPool, config, amountOut, feeMode, tradeDirection, currentPoint, eligibleForFirstSwapWithMinFee) {
+  let fees = NO_FEES;
+  let includedFeeOutAmount = amountOut;
+  if (!feeMode.feesOnInput) {
+    const feeNumerator = tradeFeeNumerator(
+      virtualPool,
+      config,
+      currentPoint,
+      tradeDirection,
+      amountOut,
+      true,
+      eligibleForFirstSwapWithMinFee
+    );
+    ({ amount: includedFeeOutAmount, fees } = addFee(
+      feeNumerator,
+      amountOut,
+      feeMode.hasReferral
+    ));
+  }
+  const { amountIn, nextSqrtPrice } = tradeDirection === 0 /* BaseToQuote */ ? calculateBaseToQuoteFromAmountOut(
+    config,
+    virtualPool.poolState.sqrtPrice,
+    includedFeeOutAmount
+  ) : calculateQuoteToBaseFromAmountOut(
+    config,
+    virtualPool.poolState.sqrtPrice,
+    includedFeeOutAmount
+  );
+  if (nextSqrtPrice.gt(config.migrationSqrtPrice)) {
+    throw new Error(ProgramError.InsufficientLiquidity);
+  }
+  let includedFeeInputAmount = amountIn;
+  if (feeMode.feesOnInput) {
+    const feeNumerator = tradeFeeNumerator(
+      virtualPool,
+      config,
+      currentPoint,
+      tradeDirection,
+      amountIn,
+      true,
+      eligibleForFirstSwapWithMinFee
+    );
+    ({ amount: includedFeeInputAmount, fees } = addFee(
+      feeNumerator,
+      amountIn,
+      feeMode.hasReferral
+    ));
+  }
+  return {
+    amountLeft: ZERO2,
+    includedFeeInputAmount,
+    excludedFeeInputAmount: amountIn,
+    outputAmount: amountOut,
+    nextSqrtPrice,
+    ...fees
+  };
+}
+function calculateBaseToQuoteFromAmountIn(configState, currentSqrtPrice, amountIn) {
+  let totalOutputAmount = ZERO2;
+  let sqrtPrice = currentSqrtPrice;
+  let amountLeft = amountIn;
+  for (let i = configState.curve.length - 2; i >= 0; i--) {
+    const point = configState.curve[i];
+    const liquidity = configState.curve[i + 1].liquidity;
+    if (point.sqrtPrice.isZero() || point.liquidity.isZero()) {
+      continue;
+    }
+    if (!point.sqrtPrice.lt(sqrtPrice)) {
+      continue;
+    }
+    const maxAmountIn = getDeltaAmountBaseUnsigned256(
+      point.sqrtPrice,
+      sqrtPrice,
+      liquidity,
+      0 /* Up */
+    );
+    if (amountLeft.lt(maxAmountIn)) {
+      const nextSqrtPrice = getNextSqrtPriceFromInput(
+        sqrtPrice,
+        liquidity,
+        amountLeft,
+        true
+      );
+      totalOutputAmount = addU64(
+        totalOutputAmount,
+        getDeltaAmountQuoteUnsigned(
+          nextSqrtPrice,
+          sqrtPrice,
+          liquidity,
+          1 /* Down */
+        )
+      );
+      sqrtPrice = nextSqrtPrice;
+      amountLeft = ZERO2;
+      break;
+    }
+    totalOutputAmount = addU64(
+      totalOutputAmount,
+      getDeltaAmountQuoteUnsigned(
+        point.sqrtPrice,
+        sqrtPrice,
+        liquidity,
+        1 /* Down */
+      )
+    );
+    sqrtPrice = point.sqrtPrice;
+    amountLeft = SafeMath.sub(amountLeft, u64(maxAmountIn));
+  }
+  if (!amountLeft.isZero()) {
+    const liquidity = configState.curve[0].liquidity;
+    let nextSqrtPrice = getNextSqrtPriceFromInput(
+      sqrtPrice,
+      liquidity,
+      amountLeft,
+      true
+    );
+    if (nextSqrtPrice.lt(configState.sqrtStartPrice)) {
+      nextSqrtPrice = configState.sqrtStartPrice;
+      amountLeft = SafeMath.sub(
+        amountLeft,
+        getDeltaAmountBaseUnsigned(
+          nextSqrtPrice,
+          sqrtPrice,
+          liquidity,
+          0 /* Up */
+        )
+      );
+    } else {
+      amountLeft = ZERO2;
+    }
+    totalOutputAmount = addU64(
+      totalOutputAmount,
+      getDeltaAmountQuoteUnsigned(
+        nextSqrtPrice,
+        sqrtPrice,
+        liquidity,
+        1 /* Down */
+      )
+    );
+    sqrtPrice = nextSqrtPrice;
+  }
+  return {
+    amountLeft,
+    outputAmount: totalOutputAmount,
+    nextSqrtPrice: sqrtPrice
+  };
+}
+function calculateQuoteToBaseFromAmountIn(configState, currentSqrtPrice, amountIn, stopSqrtPrice) {
+  let totalOutputAmount = ZERO2;
+  let sqrtPrice = currentSqrtPrice;
+  let amountLeft = amountIn;
+  for (const point of configState.curve) {
+    if (point.sqrtPrice.isZero() || point.liquidity.isZero()) {
+      break;
+    }
+    const referenceSqrtPrice = BN12.min(stopSqrtPrice, point.sqrtPrice);
+    if (!referenceSqrtPrice.gt(sqrtPrice)) {
+      continue;
+    }
+    const maxAmountIn = getDeltaAmountQuoteUnsigned256(
+      sqrtPrice,
+      referenceSqrtPrice,
+      point.liquidity,
+      0 /* Up */
+    );
+    if (amountLeft.lt(maxAmountIn)) {
+      const nextSqrtPrice = getNextSqrtPriceFromInput(
+        sqrtPrice,
+        point.liquidity,
+        amountLeft,
+        false
+      );
+      totalOutputAmount = addU64(
+        totalOutputAmount,
+        getDeltaAmountBaseUnsigned(
+          sqrtPrice,
+          nextSqrtPrice,
+          point.liquidity,
+          1 /* Down */
+        )
+      );
+      sqrtPrice = nextSqrtPrice;
+      amountLeft = ZERO2;
+      break;
+    }
+    totalOutputAmount = addU64(
+      totalOutputAmount,
+      getDeltaAmountBaseUnsigned(
+        sqrtPrice,
+        referenceSqrtPrice,
+        point.liquidity,
+        1 /* Down */
+      )
+    );
+    sqrtPrice = referenceSqrtPrice;
+    amountLeft = SafeMath.sub(amountLeft, u64(maxAmountIn));
+    if (sqrtPrice.eq(stopSqrtPrice)) {
+      break;
+    }
+  }
+  return {
+    outputAmount: totalOutputAmount,
+    nextSqrtPrice: sqrtPrice,
+    amountLeft
+  };
+}
+function calculateBaseToQuoteFromAmountOut(configState, currentSqrtPrice, outAmount) {
+  let sqrtPrice = currentSqrtPrice;
+  let amountLeft = outAmount;
+  let totalAmountIn = ZERO2;
+  for (let i = configState.curve.length - 2; i >= 0; i--) {
+    const point = configState.curve[i];
+    const liquidity = configState.curve[i + 1].liquidity;
+    if (point.sqrtPrice.isZero() || point.liquidity.isZero()) {
+      continue;
+    }
+    if (!point.sqrtPrice.lt(sqrtPrice)) {
+      continue;
+    }
+    const maxAmountOut = getDeltaAmountQuoteUnsigned256(
+      point.sqrtPrice,
+      sqrtPrice,
+      liquidity,
+      1 /* Down */
+    );
+    if (amountLeft.lt(maxAmountOut)) {
+      const nextSqrtPrice = getNextSqrtPriceFromOutput(
+        sqrtPrice,
+        liquidity,
+        amountLeft,
+        true
+      );
+      totalAmountIn = addU64(
+        totalAmountIn,
+        getDeltaAmountBaseUnsigned(
+          nextSqrtPrice,
+          sqrtPrice,
+          liquidity,
+          0 /* Up */
+        )
+      );
+      sqrtPrice = nextSqrtPrice;
+      amountLeft = ZERO2;
+      break;
+    }
+    totalAmountIn = addU64(
+      totalAmountIn,
+      getDeltaAmountBaseUnsigned(
+        point.sqrtPrice,
+        sqrtPrice,
+        liquidity,
+        0 /* Up */
+      )
+    );
+    sqrtPrice = point.sqrtPrice;
+    amountLeft = SafeMath.sub(amountLeft, u64(maxAmountOut));
+  }
+  if (!amountLeft.isZero()) {
+    const liquidity = configState.curve[0].liquidity;
+    const maxAmountOut = getDeltaAmountQuoteUnsigned256(
+      configState.sqrtStartPrice,
+      sqrtPrice,
+      liquidity,
+      1 /* Down */
+    );
+    if (amountLeft.gt(maxAmountOut)) {
+      throw new Error(ProgramError.InsufficientLiquidity);
+    }
+    const nextSqrtPrice = getNextSqrtPriceFromOutput(
+      sqrtPrice,
+      liquidity,
+      amountLeft,
+      true
+    );
+    if (nextSqrtPrice.lt(configState.sqrtStartPrice)) {
+      throw new Error(ProgramError.InsufficientLiquidity);
+    }
+    totalAmountIn = addU64(
+      totalAmountIn,
+      getDeltaAmountBaseUnsigned(
+        nextSqrtPrice,
+        sqrtPrice,
+        liquidity,
+        0 /* Up */
+      )
+    );
+    sqrtPrice = nextSqrtPrice;
+  }
+  return { amountIn: totalAmountIn, nextSqrtPrice: sqrtPrice };
+}
+function calculateQuoteToBaseFromAmountOut(configState, currentSqrtPrice, outAmount) {
+  let totalInAmount = ZERO2;
+  let sqrtPrice = currentSqrtPrice;
+  let amountLeft = outAmount;
+  for (const point of configState.curve) {
+    if (point.sqrtPrice.isZero() || point.liquidity.isZero()) {
+      break;
+    }
+    if (!point.sqrtPrice.gt(sqrtPrice)) {
+      continue;
+    }
+    const maxAmountOut = getDeltaAmountBaseUnsigned256(
+      sqrtPrice,
+      point.sqrtPrice,
+      point.liquidity,
+      1 /* Down */
+    );
+    if (amountLeft.lt(maxAmountOut)) {
+      const nextSqrtPrice = getNextSqrtPriceFromOutput(
+        sqrtPrice,
+        point.liquidity,
+        amountLeft,
+        false
+      );
+      totalInAmount = addU64(
+        totalInAmount,
+        getDeltaAmountQuoteUnsigned(
+          sqrtPrice,
+          nextSqrtPrice,
+          point.liquidity,
+          0 /* Up */
+        )
+      );
+      sqrtPrice = nextSqrtPrice;
+      amountLeft = ZERO2;
+      break;
+    }
+    totalInAmount = addU64(
+      totalInAmount,
+      getDeltaAmountQuoteUnsigned(
+        sqrtPrice,
+        point.sqrtPrice,
+        point.liquidity,
+        0 /* Up */
+      )
+    );
+    sqrtPrice = point.sqrtPrice;
+    amountLeft = SafeMath.sub(amountLeft, u64(maxAmountOut));
+  }
+  if (!amountLeft.isZero()) {
+    throw new Error(ProgramError.AmountLeftIsNotZero);
+  }
+  return { amountIn: totalInAmount, nextSqrtPrice: sqrtPrice };
+}
+function quoteExactIn(virtualPool, config, swapBaseForQuote, amountIn, slippageBps, hasReferral, currentPoint, eligibleForFirstSwapWithMinFee, transferFees) {
+  const { tradeDirection, feeMode, input, output } = beginSwapQuote(
+    virtualPool,
+    config,
+    swapBaseForQuote,
+    amountIn,
+    hasReferral,
+    transferFees
+  );
+  const excludedAmountIn = calculateTransferFeeExcludedAmount(
+    input,
+    amountIn
+  ).amount;
+  if (excludedAmountIn.isZero()) {
+    throw new Error(ProgramError.AmountIsZero);
+  }
+  const result = getSwapResultFromExactInput(
+    virtualPool,
+    config,
+    excludedAmountIn,
+    feeMode,
+    tradeDirection,
+    currentPoint,
+    isFirstSwapWithMinFee(
+      virtualPool,
+      config,
+      hasReferral,
+      eligibleForFirstSwapWithMinFee
+    )
+  );
+  const excludedAmountOut = calculateTransferFeeExcludedAmount(
+    output,
+    result.outputAmount
+  ).amount;
+  return {
+    ...result,
+    minimumAmountOut: minimumAmountOutWithSlippage(
+      excludedAmountOut,
+      slippageBps
+    ),
+    includedTransferFeeAmountIn: amountIn,
+    excludedTransferFeeAmountOut: excludedAmountOut
+  };
+}
+function swapQuote(virtualPool, config, swapBaseForQuote, amountIn, slippageBps = 0, hasReferral, currentPoint, eligibleForFirstSwapWithMinFee, transferFees) {
+  const result = quoteExactIn(
+    virtualPool,
+    config,
+    swapBaseForQuote,
+    amountIn,
+    slippageBps,
+    hasReferral,
+    currentPoint,
+    eligibleForFirstSwapWithMinFee,
+    transferFees
+  );
+  return {
+    actualInputAmount: result.excludedFeeInputAmount,
+    outputAmount: result.outputAmount,
+    nextSqrtPrice: result.nextSqrtPrice,
+    tradingFee: result.tradingFee,
+    protocolFee: result.protocolFee,
+    referralFee: result.referralFee,
+    minimumAmountOut: result.minimumAmountOut,
+    includedTransferFeeAmountIn: result.includedTransferFeeAmountIn,
+    excludedTransferFeeAmountOut: result.excludedTransferFeeAmountOut
+  };
+}
+function swapQuoteExactIn(virtualPool, config, swapBaseForQuote, amountIn, slippageBps = 0, hasReferral, currentPoint, eligibleForFirstSwapWithMinFee, transferFees) {
+  return quoteExactIn(
+    virtualPool,
+    config,
+    swapBaseForQuote,
+    amountIn,
+    slippageBps,
+    hasReferral,
+    currentPoint,
+    eligibleForFirstSwapWithMinFee,
+    transferFees
+  );
+}
+function swapQuotePartialFill(virtualPool, config, swapBaseForQuote, amountIn, slippageBps = 0, hasReferral, currentPoint, eligibleForFirstSwapWithMinFee, transferFees) {
+  const { tradeDirection, feeMode, input, output } = beginSwapQuote(
+    virtualPool,
+    config,
+    swapBaseForQuote,
+    amountIn,
+    hasReferral,
+    transferFees
+  );
+  const excludedAmountIn = calculateTransferFeeExcludedAmount(
+    input,
+    amountIn
+  ).amount;
+  if (excludedAmountIn.isZero()) {
+    throw new Error(ProgramError.AmountIsZero);
+  }
+  const result = getSwapResultFromPartialInput(
+    virtualPool,
+    config,
+    excludedAmountIn,
+    feeMode,
+    tradeDirection,
+    currentPoint,
+    isFirstSwapWithMinFee(
+      virtualPool,
+      config,
+      hasReferral,
+      eligibleForFirstSwapWithMinFee
+    )
+  );
+  const includedAmountIn = result.amountLeft.isZero() ? amountIn : calculateTransferFeeIncludedAmount(
+    input,
+    result.includedFeeInputAmount
+  ).amount;
+  if (includedAmountIn.gt(amountIn)) {
+    throw new Error(ProgramError.ExceededInputAmount);
+  }
+  const excludedAmountOut = calculateTransferFeeExcludedAmount(
+    output,
+    result.outputAmount
+  ).amount;
+  return {
+    ...result,
+    minimumAmountOut: minimumAmountOutWithSlippage(
+      excludedAmountOut,
+      slippageBps
+    ),
+    includedTransferFeeAmountIn: includedAmountIn,
+    excludedTransferFeeAmountOut: excludedAmountOut
+  };
+}
+function swapQuoteExactOut(virtualPool, config, swapBaseForQuote, outAmount, slippageBps = 0, hasReferral, currentPoint, eligibleForFirstSwapWithMinFee, transferFees) {
+  const { tradeDirection, feeMode, input, output } = beginSwapQuote(
+    virtualPool,
+    config,
+    swapBaseForQuote,
+    outAmount,
+    hasReferral,
+    transferFees
+  );
+  const includedAmountOut = calculateTransferFeeIncludedAmount(
+    output,
+    outAmount
+  ).amount;
+  if (includedAmountOut.isZero()) {
+    throw new Error(ProgramError.AmountIsZero);
+  }
+  const result = getSwapResultFromExactOutput(
+    virtualPool,
+    config,
+    includedAmountOut,
+    feeMode,
+    tradeDirection,
+    currentPoint,
+    isFirstSwapWithMinFee(
+      virtualPool,
+      config,
+      hasReferral,
+      eligibleForFirstSwapWithMinFee
+    )
+  );
+  const includedAmountIn = calculateTransferFeeIncludedAmount(
+    input,
+    result.includedFeeInputAmount
+  ).amount;
+  return {
+    ...result,
+    maximumAmountIn: maximumAmountInWithSlippage(
+      includedAmountIn,
+      slippageBps
+    ),
+    includedTransferFeeAmountIn: includedAmountIn,
+    excludedTransferFeeAmountOut: outAmount
+  };
+}
+
+export {
+  ActivationType,
+  TokenType,
+  CollectFeeMode,
+  MigratedCollectFeeMode,
+  DammV2DynamicFeeMode,
+  DammV2BaseFeeMode,
+  MigrationOption,
+  BaseFeeMode,
+  MigrationFeeOption,
+  TokenDecimal,
+  TradeDirection,
+  Rounding,
+  TokenAuthorityOption,
+  SwapMode,
+  TransferFeeWithheldAuthority,
+  MigratedTransferFeeAuthorityOption,
+  AccountsType,
+  MAX_CURVE_POINT,
+  RESOLUTION,
+  ONE_Q64,
+  FEE_DENOMINATOR,
+  MAX_BASIS_POINT,
+  MAX_BASE_TRANSFER_FEE_BPS,
+  LEGACY_CONFIG_VERSION,
+  U16_MAX,
+  U24_MAX,
+  U64_MAX,
+  U128_MAX,
+  MIN_SQRT_PRICE,
+  MAX_SQRT_PRICE,
+  MIN_FEE_BPS,
+  MAX_FEE_BPS,
+  MIN_FEE_NUMERATOR,
+  MAX_FEE_NUMERATOR,
+  MAX_RATE_LIMITER_DURATION_IN_SECONDS,
+  MAX_RATE_LIMITER_DURATION_IN_SLOTS,
+  DYNAMIC_FEE_FILTER_PERIOD_DEFAULT,
+  DYNAMIC_FEE_DECAY_PERIOD_DEFAULT,
+  DYNAMIC_FEE_REDUCTION_FACTOR_DEFAULT,
+  DYNAMIC_FEE_SCALING_FACTOR,
+  DYNAMIC_FEE_ROUNDING_OFFSET,
+  BIN_STEP_BPS_DEFAULT,
+  BIN_STEP_BPS_U128_DEFAULT,
+  MAX_PRICE_CHANGE_BPS_DEFAULT,
+  MAX_DYNAMIC_FEE_PERCENT,
+  PROTOCOL_FEE_PERCENT,
+  PARTNER_AND_CREATOR_SURPLUS_SHARE,
+  HOST_FEE_PERCENT,
+  SWAP_BUFFER_PERCENTAGE,
+  PROTOCOL_LIQUIDITY_MIGRATION_FEE_BPS,
+  DAMM_V2_COMPOUNDING_DEAD_LIQUIDITY,
+  MAX_MIGRATION_FEE_PERCENTAGE,
+  MAX_CREATOR_MIGRATION_FEE_PERCENTAGE,
+  MIN_LOCKED_LIQUIDITY_BPS,
+  SECONDS_PER_DAY,
+  MAX_LOCK_DURATION_IN_SECONDS,
+  PROTOCOL_POOL_CREATION_FEE_PERCENT,
+  MIN_POOL_CREATION_FEE,
+  MAX_POOL_CREATION_FEE,
+  MIN_MIGRATED_POOL_FEE_BPS,
+  MAX_MIGRATED_POOL_FEE_BPS,
+  DYNAMIC_BONDING_CURVE_PROGRAM_ID,
+  METAPLEX_PROGRAM_ID,
+  DAMM_V1_PROGRAM_ID,
+  DAMM_V2_PROGRAM_ID,
+  VAULT_PROGRAM_ID,
+  LOCKER_PROGRAM_ID,
+  BASE_ADDRESS,
+  DAMM_V1_MIGRATION_FEE_ADDRESS,
+  DAMM_V2_MIGRATION_FEE_ADDRESS,
+  DEFAULT_MIGRATED_POOL_FEE_PARAMS,
+  DEFAULT_LIQUIDITY_VESTING_INFO_PARAMS,
+  DEFAULT_MIGRATED_POOL_MARKET_CAP_FEE_SCHEDULER_PARAMS,
+  ProgramError,
+  SafeMath,
+  pow,
+  mulDiv,
+  toNumerator,
+  sqrt,
+  getInitialLiquidityFromDeltaQuote,
+  getInitialLiquidityFromDeltaBase,
+  getDeltaAmountBaseUnsigned,
+  getDeltaAmountBaseUnsigned256,
+  getDeltaAmountQuoteUnsigned,
+  getDeltaAmountQuoteUnsigned256,
+  getNextSqrtPriceFromInput,
+  getNextSqrtPriceFromOutput,
+  getNextSqrtPriceFromQuoteAmountOutRoundingDown,
+  getNextSqrtPriceFromBaseAmountOutRoundingUp,
+  getNextSqrtPriceFromBaseAmountInRoundingUp,
+  getNextSqrtPriceFromQuoteAmountInRoundingDown,
+  liveCurve,
+  isZeroTransferFee,
+  getBaseTransferFee,
+  getEpochTransferFee,
+  resolveSwapTransferFees,
+  calculateTransferFeeExcludedAmount,
+  calculateTransferFeeIncludedAmount,
+  getFeeSchedulerMinBaseFeeNumerator,
+  getBaseFeeNumeratorByPeriod,
+  getFeeNumeratorOnLinearFeeScheduler,
+  getFeeNumeratorOnExponentialFeeScheduler,
+  getBaseFeeNumerator,
+  getExcludedFeeAmount,
+  getIncludedFeeAmount,
+  isRateLimiterApplied,
+  isZeroRateLimiter,
+  isNonZeroRateLimiter,
+  getMaxIndex,
+  getCheckedAmounts,
+  getFeeNumeratorFromExcludedAmount,
+  getRateLimiterExcludedFeeAmount,
+  getMaxOutAmountWithMinBaseFee,
+  getFeeNumeratorFromIncludedAmount,
+  FeeRateLimiter,
+  FeeScheduler,
+  getBaseFeeHandler,
+  isDynamicFeeEnabled,
+  getVariableFeeNumerator,
+  getFeeMode,
+  getTotalFeeNumeratorFromIncludedFeeAmount,
+  getTotalFeeNumeratorFromExcludedFeeAmount,
+  getTotalFeeNumerator,
+  getFeeOnAmount,
+  splitFees,
+  getSwapResultFromExactInput,
+  getSwapResult,
+  getSwapResultFromPartialInput,
+  getSwapResultFromExactOutput,
+  calculateBaseToQuoteFromAmountIn,
+  calculateQuoteToBaseFromAmountIn,
+  calculateBaseToQuoteFromAmountOut,
+  calculateQuoteToBaseFromAmountOut,
+  swapQuote,
+  swapQuoteExactIn,
+  swapQuotePartialFill,
+  swapQuoteExactOut
+};
+//# sourceMappingURL=chunk-P4K4GKFH.js.map