@apex_labs/sdk 0.1.1 → 0.2.0

package/dist/index.js

@@ -97,13 +97,6 @@ var NFT_POSITION_MANAGER_ADDRESSES = {
   [ChainId.MONAD_MAINNET]: NFT_POSITION_MANAGER_ADDRESS,
   [ChainId.MONAD_TESTNET]: "0x075A0Ba7bc4cdFBBdc9d8De5f228C834246e5AFc"
 };
-var FeeAmount = /* @__PURE__ */ ((FeeAmount4) => {
-  FeeAmount4[FeeAmount4["LOWEST"] = 100] = "LOWEST";
-  FeeAmount4[FeeAmount4["LOW"] = 500] = "LOW";
-  FeeAmount4[FeeAmount4["MEDIUM"] = 2500] = "MEDIUM";
-  FeeAmount4[FeeAmount4["HIGH"] = 1e4] = "HIGH";
-  return FeeAmount4;
-})(FeeAmount || {});
 var TICK_SPACINGS = {
   [
     100
@@ -826,25 +819,6 @@ function tickToPrice(baseToken, quoteToken, tick) {
   const ratioX192 = sqrtRatioX96 * sqrtRatioX96;
   return isCurrencySorted(baseToken, quoteToken) ? new Price$1(baseToken, quoteToken, Q192, ratioX192) : new Price$1(baseToken, quoteToken, ratioX192, Q192);
 }
-function tickToPriceV2(baseToken, quoteToken, tick) {
-  const sqrtRatioX96 = TickMath.getSqrtRatioAtTick(tick);
-  const ratioX192 = sqrtRatioX96 * sqrtRatioX96;
-  return sortCurrencies([baseToken, quoteToken])[0] === baseToken ? new Price$1(baseToken, quoteToken, Q192, ratioX192) : new Price$1(baseToken, quoteToken, ratioX192, Q192);
-}
-function priceToClosestTick(price) {
-  const sorted = isCurrencySorted(price.baseCurrency, price.quoteCurrency);
-  const sqrtRatioX96 = sorted ? encodeSqrtRatioX96(price.numerator, price.denominator) : encodeSqrtRatioX96(price.denominator, price.numerator);
-  let tick = TickMath.getTickAtSqrtRatio(sqrtRatioX96);
-  const nextTickPrice = tickToPrice(price.baseCurrency, price.quoteCurrency, tick + 1);
-  if (sorted) {
-    if (!price.lessThan(nextTickPrice)) {
-      tick++;
-    }
-  } else if (!price.greaterThan(nextTickPrice)) {
-    tick++;
-  }
-  return tick;
-}
 function getToken0Amount(tickCurrent, tickLower, tickUpper, sqrtRatioX96, liquidity) {
   if (tickCurrent < tickLower) {
     return SqrtPriceMath.getAmount0Delta(
@@ -1657,54 +1631,7 @@ var Trade = class {
     return bestTrades;
   }
 };
-var getCurrency0Price = ([currency0, currency1], currentSqrtRatioX96) => {
-  const ratio192 = BigInt(currentSqrtRatioX96) * BigInt(currentSqrtRatioX96);
-  return new Price(currency0, currency1, Q192, ratio192);
-};
-var getCurrency1Price = ([currency0, currency1], currentSqrtRatioX96) => {
-  const ratio192 = BigInt(currentSqrtRatioX96) * BigInt(currentSqrtRatioX96);
-  return new Price(currency1, currency0, Q192, ratio192);
-};
 var NO_TICK_DATA_PROVIDER_DEFAULT2 = new NoTickDataProvider();
-var MAX_FEE_AMOUNT = 1000000n;
-var getPool = ({
-  currencyA,
-  currencyB,
-  fee,
-  sqrtRatioX96,
-  liquidity,
-  tickCurrent,
-  tickSpacing,
-  ticks = NO_TICK_DATA_PROVIDER_DEFAULT2
-}) => {
-  invariant9(Number.isInteger(fee) && BigInt(fee) < MAX_FEE_AMOUNT, "FEE");
-  const [currency0, currency1] = sortCurrencies([currencyA, currencyB]);
-  return {
-    currency0,
-    currency1,
-    fee,
-    tickCurrent,
-    tickSpacing,
-    sqrtRatioX96: BigInt(sqrtRatioX96),
-    liquidity: BigInt(liquidity),
-    tickDataProvider: Array.isArray(ticks) ? new TickListDataProvider(ticks) : ticks
-  };
-};
-var getPriceOfCurrency = (pool, currency) => {
-  if (currency.isNative) {
-    invariant9(pool.currency0.isNative, "CURRENCY");
-    return getCurrency0Price([pool.currency0, pool.currency1], pool.sqrtRatioX96);
-  }
-  invariant9(pool.currency0.equals(currency) || pool.currency1.equals(currency), "CURRENCY");
-  return pool.currency0.equals(currency) ? getCurrency0Price([pool.currency0, pool.currency1], pool.sqrtRatioX96) : getCurrency1Price([pool.currency0, pool.currency1], pool.sqrtRatioX96);
-};
-var getPriceOfCurrency0 = (pool) => getCurrency0Price([pool.currency0, pool.currency1], pool.sqrtRatioX96);
-var getPriceOfCurrency1 = (pool) => getCurrency1Price([pool.currency0, pool.currency1], pool.sqrtRatioX96);
-var hasInvolvedCurrency = (pool, currency) => {
-  if (currency.isNative)
-    return pool.currency0.isNative && pool.currency1.chainId === currency.chainId;
-  return pool.currency0.equals(currency) || pool.currency1.equals(currency);
-};
 function toHex(bigintIsh) {
   const bigInt = BigInt(bigintIsh);
   let hex = bigInt.toString(16);
@@ -1748,403 +1675,8 @@ function nearestUsableTick(tick, tickSpacing) {
     return rounded - tickSpacing;
   return rounded;
 }
-var PositionLibrary = class {
-  /**
-   * Cannot be constructed.
-   */
-  constructor() {
-  }
-  // replicates the portions of Position#update required to compute unaccounted fees
-  static getTokensOwed(feeGrowthInside0LastX128, feeGrowthInside1LastX128, liquidity, feeGrowthInside0X128, feeGrowthInside1X128) {
-    const tokensOwed0 = subIn256(feeGrowthInside0X128, feeGrowthInside0LastX128) * liquidity / Q128;
-    const tokensOwed1 = subIn256(feeGrowthInside1X128, feeGrowthInside1LastX128) * liquidity / Q128;
-    return [tokensOwed0, tokensOwed1];
-  }
-};
 var Q256 = 2n ** 256n;
-function subIn256(x, y) {
-  const difference = x - y;
-  if (difference < ZERO) {
-    return Q256 + difference;
-  }
-  return difference;
-}
-var TickLibrary = class {
-  /**
-   * Cannot be constructed.
-   */
-  constructor() {
-  }
-  static getFeeGrowthInside(feeGrowthOutsideLower, feeGrowthOutsideUpper, tickLower, tickUpper, tickCurrent, feeGrowthGlobal0X128, feeGrowthGlobal1X128) {
-    let feeGrowthBelow0X128;
-    let feeGrowthBelow1X128;
-    if (tickCurrent >= tickLower) {
-      feeGrowthBelow0X128 = feeGrowthOutsideLower.feeGrowthOutside0X128;
-      feeGrowthBelow1X128 = feeGrowthOutsideLower.feeGrowthOutside1X128;
-    } else {
-      feeGrowthBelow0X128 = subIn256(feeGrowthGlobal0X128, feeGrowthOutsideLower.feeGrowthOutside0X128);
-      feeGrowthBelow1X128 = subIn256(feeGrowthGlobal1X128, feeGrowthOutsideLower.feeGrowthOutside1X128);
-    }
-    let feeGrowthAbove0X128;
-    let feeGrowthAbove1X128;
-    if (tickCurrent < tickUpper) {
-      feeGrowthAbove0X128 = feeGrowthOutsideUpper.feeGrowthOutside0X128;
-      feeGrowthAbove1X128 = feeGrowthOutsideUpper.feeGrowthOutside1X128;
-    } else {
-      feeGrowthAbove0X128 = subIn256(feeGrowthGlobal0X128, feeGrowthOutsideUpper.feeGrowthOutside0X128);
-      feeGrowthAbove1X128 = subIn256(feeGrowthGlobal1X128, feeGrowthOutsideUpper.feeGrowthOutside1X128);
-    }
-    return [
-      subIn256(subIn256(feeGrowthGlobal0X128, feeGrowthBelow0X128), feeGrowthAbove0X128),
-      subIn256(subIn256(feeGrowthGlobal1X128, feeGrowthBelow1X128), feeGrowthAbove1X128)
-    ];
-  }
-};
-function parseNumberToFraction(num, precision = 6) {
-  if (Number.isNaN(num) || !Number.isFinite(num)) {
-    return void 0;
-  }
-  const scalar = 10 ** precision;
-  const scaledNum = num * scalar;
-  if (Number.isNaN(scaledNum) || !Number.isFinite(scaledNum)) {
-    return void 0;
-  }
-  return new Fraction$1(BigInt(Math.floor(scaledNum)), BigInt(scalar));
-}
-var FeeCalculator = {
-  getEstimatedLPFee,
-  getEstimatedLPFeeByAmounts,
-  getLiquidityFromTick,
-  getLiquidityFromSqrtRatioX96,
-  getAverageLiquidity,
-  getLiquidityBySingleAmount,
-  getDependentAmount,
-  getLiquidityByAmountsAndPrice,
-  getAmountsByLiquidityAndPrice,
-  getAmountsAtNewPrice
-};
-function getEstimatedLPFeeWithProtocolFee({ amount, currency, ...rest }) {
-  return getEstimatedLPFeeByAmountsWithProtocolFee({
-    ...rest,
-    amountA: amount,
-    amountB: CurrencyAmount$1.fromRawAmount(currency, MaxUint256)
-  });
-}
-function getEstimatedLPFee({ amount, currency, ...rest }) {
-  return getEstimatedLPFeeByAmounts({
-    ...rest,
-    amountA: amount,
-    amountB: CurrencyAmount$1.fromRawAmount(currency, MaxUint256)
-  });
-}
-function getEstimatedLPFeeByAmountsWithProtocolFee(options) {
-  try {
-    return tryGetEstimatedLPFeeByAmounts(options);
-  } catch (e) {
-    console.error(e);
-    return new Fraction$1(ZERO$1);
-  }
-}
-function getEstimatedLPFeeByAmounts({ protocolFee = ZERO_PERCENT, ...rest }) {
-  try {
-    const fee = tryGetEstimatedLPFeeByAmounts(rest);
-    return ONE_HUNDRED_PERCENT.subtract(protocolFee).multiply(fee).asFraction;
-  } catch (e) {
-    console.error(e);
-    return new Fraction$1(ZERO$1);
-  }
-}
-function tryGetEstimatedLPFeeByAmounts({
-  amountA,
-  amountB,
-  volume24H,
-  sqrtRatioX96,
-  tickLower,
-  tickUpper,
-  mostActiveLiquidity,
-  fee,
-  insidePercentage = ONE_HUNDRED_PERCENT
-}) {
-  invariant9(!Number.isNaN(fee) && fee >= 0, "INVALID_FEE");
-  const tickCurrent = TickMath.getTickAtSqrtRatio(sqrtRatioX96);
-  if (tickCurrent < tickLower || tickCurrent >= tickUpper) {
-    return new Fraction$1(ZERO$1);
-  }
-  const liquidity = FeeCalculator.getLiquidityByAmountsAndPrice({
-    amountA,
-    amountB,
-    tickUpper,
-    tickLower,
-    sqrtRatioX96
-  });
-  if (!liquidity) {
-    return new Fraction$1(ZERO$1);
-  }
-  const volumeInFraction = parseNumberToFraction(volume24H) || new Fraction$1(ZERO$1);
-  return insidePercentage.multiply(volumeInFraction.multiply(BigInt(fee)).multiply(liquidity)).divide(MAX_FEE * (liquidity + mostActiveLiquidity)).asFraction;
-}
-function getDependentAmount(options) {
-  const { currency, amount, sqrtRatioX96, tickLower, tickUpper } = options;
-  const currentTick = TickMath.getTickAtSqrtRatio(sqrtRatioX96);
-  const liquidity = FeeCalculator.getLiquidityBySingleAmount(options);
-  const isToken0 = currency.wrapped.sortsBefore(amount.currency.wrapped);
-  const getTokenAmount = isToken0 ? PositionMath.getToken0Amount : PositionMath.getToken1Amount;
-  if (!liquidity) {
-    return void 0;
-  }
-  return CurrencyAmount$1.fromRawAmount(
-    currency,
-    getTokenAmount(currentTick, tickLower, tickUpper, sqrtRatioX96, liquidity)
-  );
-}
-function getLiquidityBySingleAmount({ amount, currency, ...rest }) {
-  return getLiquidityByAmountsAndPrice({
-    amountA: amount,
-    amountB: CurrencyAmount$1.fromRawAmount(currency, MaxUint256),
-    ...rest
-  });
-}
-function getLiquidityByAmountsAndPrice({
-  amountA,
-  amountB,
-  tickUpper,
-  tickLower,
-  sqrtRatioX96
-}) {
-  const isToken0 = amountA.currency.wrapped.address !== amountB.currency.wrapped.address ? amountA.currency.wrapped.sortsBefore(amountB.currency.wrapped) : true;
-  const [inputAmount0, inputAmount1] = isToken0 ? [amountA.quotient, amountB.quotient] : [amountB.quotient, amountA.quotient];
-  const sqrtRatioAX96 = TickMath.getSqrtRatioAtTick(tickLower);
-  const sqrtRatioBX96 = TickMath.getSqrtRatioAtTick(tickUpper);
-  try {
-    return maxLiquidityForAmounts(sqrtRatioX96, sqrtRatioAX96, sqrtRatioBX96, inputAmount0, inputAmount1, true);
-  } catch (e) {
-    console.error(e);
-    return void 0;
-  }
-}
-function getAmountsByLiquidityAndPrice(options) {
-  const { currencyA, currencyB, liquidity, sqrtRatioX96, tickLower, tickUpper } = options;
-  const currentTick = TickMath.getTickAtSqrtRatio(sqrtRatioX96);
-  const isToken0 = currencyA.wrapped.sortsBefore(currencyB.wrapped);
-  const adjustedAmount0 = PositionMath.getToken0Amount(currentTick, tickLower, tickUpper, sqrtRatioX96, liquidity);
-  const adjustedAmount1 = PositionMath.getToken1Amount(currentTick, tickLower, tickUpper, sqrtRatioX96, liquidity);
-  return [
-    CurrencyAmount$1.fromRawAmount(currencyA, isToken0 ? adjustedAmount0 : adjustedAmount1),
-    CurrencyAmount$1.fromRawAmount(currencyB, isToken0 ? adjustedAmount1 : adjustedAmount0)
-  ];
-}
-function getAmountsAtNewPrice({ newSqrtRatioX96, ...rest }) {
-  const { tickLower, tickUpper, amountA, amountB } = rest;
-  const liquidity = FeeCalculator.getLiquidityByAmountsAndPrice(rest);
-  if (!liquidity) {
-    return void 0;
-  }
-  return FeeCalculator.getAmountsByLiquidityAndPrice({
-    liquidity,
-    currencyA: amountA.currency,
-    currencyB: amountB.currency,
-    tickLower,
-    tickUpper,
-    sqrtRatioX96: newSqrtRatioX96
-  });
-}
-function getAverageLiquidity(ticks, tickSpacing, tickLower, tickUpper) {
-  invariant9(tickLower <= tickUpper, "INVALID_TICK_RANGE");
-  TickList.validateList(ticks, tickSpacing);
-  if (tickLower === tickUpper) {
-    return FeeCalculator.getLiquidityFromTick(ticks, tickLower);
-  }
-  const lowerOutOfBound = tickLower < ticks[0].index;
-  let lastTick = lowerOutOfBound ? new Tick({ index: TickMath.MIN_TICK, liquidityNet: ZERO$1, liquidityGross: ZERO$1 }) : TickList.nextInitializedTick(ticks, tickLower, true);
-  let currentTick = TickList.nextInitializedTick(ticks, tickLower, false);
-  let currentL = lowerOutOfBound ? ZERO$1 : FeeCalculator.getLiquidityFromTick(ticks, currentTick.index);
-  let weightedL = ZERO$1;
-  const getWeightedLFromLastTickTo = (toTick) => currentL * BigInt(toTick - Math.max(lastTick.index, tickLower));
-  while (currentTick.index < tickUpper) {
-    weightedL += getWeightedLFromLastTickTo(currentTick.index);
-    currentL += currentTick.liquidityNet;
-    lastTick = currentTick;
-    if (currentTick.index === ticks[ticks.length - 1].index) {
-      break;
-    }
-    currentTick = TickList.nextInitializedTick(ticks, currentTick.index, false);
-  }
-  weightedL += getWeightedLFromLastTickTo(tickUpper);
-  return weightedL / BigInt(tickUpper - tickLower);
-}
-function getLiquidityFromSqrtRatioX96(ticks, sqrtRatioX96) {
-  const tick = TickMath.getTickAtSqrtRatio(sqrtRatioX96);
-  return FeeCalculator.getLiquidityFromTick(ticks, tick);
-}
-function getLiquidityFromTick(ticks, tick) {
-  let liquidity = ZERO$1;
-  if (!ticks?.length)
-    return liquidity;
-  if (tick < ticks[0].index || tick > ticks[ticks.length - 1].index) {
-    return liquidity;
-  }
-  for (let i = 0; i < ticks.length - 1; ++i) {
-    liquidity += ticks[i].liquidityNet;
-    const lowerTick = ticks[i].index;
-    const upperTick = ticks[i + 1]?.index;
-    if (lowerTick <= tick && tick <= upperTick) {
-      break;
-    }
-  }
-  return liquidity;
-}
 var FEE_BASE = 10n ** 4n;
-function parseProtocolFees(feeProtocol) {
-  const packed = Number(feeProtocol);
-  if (Number.isNaN(packed)) {
-    throw new Error(`Invalid fee protocol ${feeProtocol}`);
-  }
-  const token0ProtocolFee = packed % 2 ** 16;
-  const token1ProtocolFee = packed >> 16;
-  return [new Percent(token0ProtocolFee, FEE_BASE), new Percent(token1ProtocolFee, FEE_BASE)];
-}
-function sqrtRatioX96ToPrice(sqrtRatioX96, currencyA, currencyB) {
-  const ratioX192 = sqrtRatioX96 * sqrtRatioX96;
-  return currencyA.wrapped.sortsBefore(currencyB.wrapped) ? new Price$1(currencyA.wrapped, currencyB.wrapped, Q192, ratioX192) : new Price$1(currencyA.wrapped, currencyB.wrapped, ratioX192, Q192);
-}
-var isPoolTickInRange = (pool, tickLower, tickUpper) => {
-  if (!pool)
-    return false;
-  const below = typeof tickLower === "number" ? pool.tickCurrent < tickLower : void 0;
-  const above = typeof tickUpper === "number" ? pool.tickCurrent >= tickUpper : void 0;
-  return typeof below === "boolean" && typeof above === "boolean" ? !below && !above : false;
-};
-var swap = async ({
-  pool,
-  zeroForOne,
-  amountSpecified,
-  sqrtPriceLimitX96
-}) => {
-  if (!sqrtPriceLimitX96)
-    sqrtPriceLimitX96 = zeroForOne ? TickMath.MIN_SQRT_RATIO + ONE : TickMath.MAX_SQRT_RATIO - ONE;
-  if (zeroForOne) {
-    invariant9(sqrtPriceLimitX96 > TickMath.MIN_SQRT_RATIO, "RATIO_MIN");
-    invariant9(sqrtPriceLimitX96 < pool.sqrtRatioX96, "RATIO_CURRENT");
-  } else {
-    invariant9(sqrtPriceLimitX96 < TickMath.MAX_SQRT_RATIO, "RATIO_MAX");
-    invariant9(sqrtPriceLimitX96 > pool.sqrtRatioX96, "RATIO_CURRENT");
-  }
-  const exactInput = amountSpecified >= ZERO;
-  const state = {
-    amountSpecifiedRemaining: amountSpecified,
-    amountCalculated: ZERO,
-    sqrtPriceX96: pool.sqrtRatioX96,
-    tick: pool.tickCurrent,
-    liquidity: pool.liquidity
-  };
-  while (state.amountSpecifiedRemaining !== ZERO && state.sqrtPriceX96 != sqrtPriceLimitX96) {
-    const step = {};
-    step.sqrtPriceStartX96 = state.sqrtPriceX96;
-    [step.tickNext, step.initialized] = await pool.tickDataProvider.nextInitializedTickWithinOneWord(
-      state.tick,
-      zeroForOne,
-      pool.tickSpacing
-    );
-    if (step.tickNext < TickMath.MIN_TICK) {
-      step.tickNext = TickMath.MIN_TICK;
-    } else if (step.tickNext > TickMath.MAX_TICK) {
-      step.tickNext = TickMath.MAX_TICK;
-    }
-    step.sqrtPriceNextX96 = TickMath.getSqrtRatioAtTick(step.tickNext);
-    [state.sqrtPriceX96, step.amountIn, step.amountOut, step.feeAmount] = SwapMath.computeSwapStep(
-      state.sqrtPriceX96,
-      (zeroForOne ? step.sqrtPriceNextX96 < sqrtPriceLimitX96 : step.sqrtPriceNextX96 > sqrtPriceLimitX96) ? sqrtPriceLimitX96 : step.sqrtPriceNextX96,
-      state.liquidity,
-      state.amountSpecifiedRemaining,
-      pool.fee
-    );
-    if (exactInput) {
-      state.amountSpecifiedRemaining -= step.amountIn + step.feeAmount;
-      state.amountCalculated = state.amountCalculated - step.amountOut;
-    } else {
-      state.amountSpecifiedRemaining = state.amountSpecifiedRemaining + step.amountOut;
-      state.amountCalculated = state.amountCalculated + (step.amountIn + step.feeAmount);
-    }
-    if (state.sqrtPriceX96 === step.sqrtPriceNextX96) {
-      if (step.initialized) {
-        let liquidityNet = BigInt((await pool.tickDataProvider.getTick(step.tickNext)).liquidityNet);
-        if (zeroForOne)
-          liquidityNet *= NEGATIVE_ONE;
-        state.liquidity = LiquidityMath.addDelta(state.liquidity, liquidityNet);
-      }
-      state.tick = zeroForOne ? step.tickNext - 1 : step.tickNext;
-    } else if (state.sqrtPriceX96 !== step.sqrtPriceStartX96) {
-      state.tick = TickMath.getTickAtSqrtRatio(state.sqrtPriceX96);
-    }
-  }
-  return {
-    amountSpecifiedRemaining: state.amountSpecifiedRemaining,
-    amountCalculated: state.amountCalculated,
-    sqrtRatioX96: state.sqrtPriceX96,
-    liquidity: state.liquidity,
-    tickCurrent: state.tick
-  };
-};
-var getOutputAmount = async (pool, inputAmount, options) => {
-  invariant9(hasInvolvedCurrency(pool, inputAmount.currency), "CURRENCY");
-  const zeroForOne = inputAmount.currency.equals(pool.currency0);
-  const { sqrtPriceLimitX96, exact } = options || {};
-  const {
-    amountCalculated: outputAmount,
-    sqrtRatioX96,
-    liquidity,
-    tickCurrent,
-    amountSpecifiedRemaining
-  } = await swap({
-    pool,
-    zeroForOne,
-    amountSpecified: inputAmount.quotient,
-    sqrtPriceLimitX96
-  });
-  const outputToken = zeroForOne ? pool.currency1 : pool.currency0;
-  if (exact) {
-    invariant9(amountSpecifiedRemaining === ZERO, "INSUFFICIENT_LIQUIDITY");
-  }
-  return [
-    CurrencyAmount.fromRawAmount(outputToken, outputAmount * NEGATIVE_ONE),
-    {
-      ...pool,
-      sqrtRatioX96,
-      liquidity,
-      tickCurrent
-    }
-  ];
-};
-var getInputAmount = async (pool, outputAmount, options) => {
-  invariant9(hasInvolvedCurrency(pool, outputAmount.currency), "CURRENCY");
-  const zeroForOne = outputAmount.currency.equals(pool.currency1);
-  const { sqrtPriceLimitX96, exact } = options || {};
-  const {
-    amountCalculated: inputAmount,
-    sqrtRatioX96,
-    liquidity,
-    tickCurrent,
-    amountSpecifiedRemaining
-  } = await swap({
-    pool,
-    zeroForOne,
-    amountSpecified: outputAmount.quotient * NEGATIVE_ONE,
-    sqrtPriceLimitX96
-  });
-  if (exact) {
-    invariant9(amountSpecifiedRemaining === ZERO, "INSUFFICIENT_LIQUIDITY");
-  }
-  const inputCurrency = zeroForOne ? pool.currency0 : pool.currency1;
-  return [
-    CurrencyAmount.fromRawAmount(inputCurrency, inputAmount),
-    {
-      ...pool,
-      sqrtRatioX96,
-      liquidity,
-      tickCurrent
-    }
-  ];
-};
 var IMulticall = [
   {
     inputs: [
@@ -6259,462 +5791,6 @@ var _SwapRouter = class {
 };
 var SwapRouter = _SwapRouter;
 SwapRouter.ABI = swapRouterABI;
-var pancakeV3PoolABI = [
-  { inputs: [], stateMutability: "nonpayable", type: "constructor" },
-  {
-    anonymous: false,
-    inputs: [
-      { indexed: true, internalType: "address", name: "owner", type: "address" },
-      { indexed: true, internalType: "int24", name: "tickLower", type: "int24" },
-      { indexed: true, internalType: "int24", name: "tickUpper", type: "int24" },
-      { indexed: false, internalType: "uint128", name: "amount", type: "uint128" },
-      { indexed: false, internalType: "uint256", name: "amount0", type: "uint256" },
-      { indexed: false, internalType: "uint256", name: "amount1", type: "uint256" }
-    ],
-    name: "Burn",
-    type: "event"
-  },
-  {
-    anonymous: false,
-    inputs: [
-      { indexed: true, internalType: "address", name: "owner", type: "address" },
-      { indexed: false, internalType: "address", name: "recipient", type: "address" },
-      { indexed: true, internalType: "int24", name: "tickLower", type: "int24" },
-      { indexed: true, internalType: "int24", name: "tickUpper", type: "int24" },
-      { indexed: false, internalType: "uint128", name: "amount0", type: "uint128" },
-      { indexed: false, internalType: "uint128", name: "amount1", type: "uint128" }
-    ],
-    name: "Collect",
-    type: "event"
-  },
-  {
-    anonymous: false,
-    inputs: [
-      { indexed: true, internalType: "address", name: "sender", type: "address" },
-      { indexed: true, internalType: "address", name: "recipient", type: "address" },
-      { indexed: false, internalType: "uint128", name: "amount0", type: "uint128" },
-      { indexed: false, internalType: "uint128", name: "amount1", type: "uint128" }
-    ],
-    name: "CollectProtocol",
-    type: "event"
-  },
-  {
-    anonymous: false,
-    inputs: [
-      { indexed: true, internalType: "address", name: "sender", type: "address" },
-      { indexed: true, internalType: "address", name: "recipient", type: "address" },
-      { indexed: false, internalType: "uint256", name: "amount0", type: "uint256" },
-      { indexed: false, internalType: "uint256", name: "amount1", type: "uint256" },
-      { indexed: false, internalType: "uint256", name: "paid0", type: "uint256" },
-      { indexed: false, internalType: "uint256", name: "paid1", type: "uint256" }
-    ],
-    name: "Flash",
-    type: "event"
-  },
-  {
-    anonymous: false,
-    inputs: [
-      { indexed: false, internalType: "uint16", name: "observationCardinalityNextOld", type: "uint16" },
-      { indexed: false, internalType: "uint16", name: "observationCardinalityNextNew", type: "uint16" }
-    ],
-    name: "IncreaseObservationCardinalityNext",
-    type: "event"
-  },
-  {
-    anonymous: false,
-    inputs: [
-      { indexed: false, internalType: "uint160", name: "sqrtPriceX96", type: "uint160" },
-      { indexed: false, internalType: "int24", name: "tick", type: "int24" }
-    ],
-    name: "Initialize",
-    type: "event"
-  },
-  {
-    anonymous: false,
-    inputs: [
-      { indexed: false, internalType: "address", name: "sender", type: "address" },
-      { indexed: true, internalType: "address", name: "owner", type: "address" },
-      { indexed: true, internalType: "int24", name: "tickLower", type: "int24" },
-      { indexed: true, internalType: "int24", name: "tickUpper", type: "int24" },
-      { indexed: false, internalType: "uint128", name: "amount", type: "uint128" },
-      { indexed: false, internalType: "uint256", name: "amount0", type: "uint256" },
-      { indexed: false, internalType: "uint256", name: "amount1", type: "uint256" }
-    ],
-    name: "Mint",
-    type: "event"
-  },
-  {
-    anonymous: false,
-    inputs: [
-      { indexed: false, internalType: "uint32", name: "feeProtocol0Old", type: "uint32" },
-      { indexed: false, internalType: "uint32", name: "feeProtocol1Old", type: "uint32" },
-      { indexed: false, internalType: "uint32", name: "feeProtocol0New", type: "uint32" },
-      { indexed: false, internalType: "uint32", name: "feeProtocol1New", type: "uint32" }
-    ],
-    name: "SetFeeProtocol",
-    type: "event"
-  },
-  {
-    anonymous: false,
-    inputs: [{ indexed: false, internalType: "address", name: "addr", type: "address" }],
-    name: "SetLmPoolEvent",
-    type: "event"
-  },
-  {
-    anonymous: false,
-    inputs: [
-      { indexed: true, internalType: "address", name: "sender", type: "address" },
-      { indexed: true, internalType: "address", name: "recipient", type: "address" },
-      { indexed: false, internalType: "int256", name: "amount0", type: "int256" },
-      { indexed: false, internalType: "int256", name: "amount1", type: "int256" },
-      { indexed: false, internalType: "uint160", name: "sqrtPriceX96", type: "uint160" },
-      { indexed: false, internalType: "uint128", name: "liquidity", type: "uint128" },
-      { indexed: false, internalType: "int24", name: "tick", type: "int24" },
-      { indexed: false, internalType: "uint128", name: "protocolFeesToken0", type: "uint128" },
-      { indexed: false, internalType: "uint128", name: "protocolFeesToken1", type: "uint128" }
-    ],
-    name: "Swap",
-    type: "event"
-  },
-  {
-    inputs: [
-      { internalType: "int24", name: "tickLower", type: "int24" },
-      { internalType: "int24", name: "tickUpper", type: "int24" },
-      { internalType: "uint128", name: "amount", type: "uint128" }
-    ],
-    name: "burn",
-    outputs: [
-      { internalType: "uint256", name: "amount0", type: "uint256" },
-      { internalType: "uint256", name: "amount1", type: "uint256" }
-    ],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    inputs: [
-      { internalType: "address", name: "recipient", type: "address" },
-      { internalType: "int24", name: "tickLower", type: "int24" },
-      { internalType: "int24", name: "tickUpper", type: "int24" },
-      { internalType: "uint128", name: "amount0Requested", type: "uint128" },
-      { internalType: "uint128", name: "amount1Requested", type: "uint128" }
-    ],
-    name: "collect",
-    outputs: [
-      { internalType: "uint128", name: "amount0", type: "uint128" },
-      { internalType: "uint128", name: "amount1", type: "uint128" }
-    ],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    inputs: [
-      { internalType: "address", name: "recipient", type: "address" },
-      { internalType: "uint128", name: "amount0Requested", type: "uint128" },
-      { internalType: "uint128", name: "amount1Requested", type: "uint128" }
-    ],
-    name: "collectProtocol",
-    outputs: [
-      { internalType: "uint128", name: "amount0", type: "uint128" },
-      { internalType: "uint128", name: "amount1", type: "uint128" }
-    ],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    inputs: [],
-    name: "factory",
-    outputs: [{ internalType: "address", name: "", type: "address" }],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [],
-    name: "fee",
-    outputs: [{ internalType: "uint24", name: "", type: "uint24" }],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [],
-    name: "feeGrowthGlobal0X128",
-    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [],
-    name: "feeGrowthGlobal1X128",
-    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [
-      { internalType: "address", name: "recipient", type: "address" },
-      { internalType: "uint256", name: "amount0", type: "uint256" },
-      { internalType: "uint256", name: "amount1", type: "uint256" },
-      { internalType: "bytes", name: "data", type: "bytes" }
-    ],
-    name: "flash",
-    outputs: [],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    inputs: [{ internalType: "uint16", name: "observationCardinalityNext", type: "uint16" }],
-    name: "increaseObservationCardinalityNext",
-    outputs: [],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    inputs: [{ internalType: "uint160", name: "sqrtPriceX96", type: "uint160" }],
-    name: "initialize",
-    outputs: [],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    inputs: [],
-    name: "liquidity",
-    outputs: [{ internalType: "uint128", name: "", type: "uint128" }],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [],
-    name: "lmPool",
-    outputs: [{ internalType: "contract IPancakeV3LmPool", name: "", type: "address" }],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [],
-    name: "maxLiquidityPerTick",
-    outputs: [{ internalType: "uint128", name: "", type: "uint128" }],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [
-      { internalType: "address", name: "recipient", type: "address" },
-      { internalType: "int24", name: "tickLower", type: "int24" },
-      { internalType: "int24", name: "tickUpper", type: "int24" },
-      { internalType: "uint128", name: "amount", type: "uint128" },
-      { internalType: "bytes", name: "data", type: "bytes" }
-    ],
-    name: "mint",
-    outputs: [
-      { internalType: "uint256", name: "amount0", type: "uint256" },
-      { internalType: "uint256", name: "amount1", type: "uint256" }
-    ],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    inputs: [{ internalType: "uint256", name: "", type: "uint256" }],
-    name: "observations",
-    outputs: [
-      { internalType: "uint32", name: "blockTimestamp", type: "uint32" },
-      { internalType: "int56", name: "tickCumulative", type: "int56" },
-      { internalType: "uint160", name: "secondsPerLiquidityCumulativeX128", type: "uint160" },
-      { internalType: "bool", name: "initialized", type: "bool" }
-    ],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [{ internalType: "uint32[]", name: "secondsAgos", type: "uint32[]" }],
-    name: "observe",
-    outputs: [
-      { internalType: "int56[]", name: "tickCumulatives", type: "int56[]" },
-      { internalType: "uint160[]", name: "secondsPerLiquidityCumulativeX128s", type: "uint160[]" }
-    ],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [{ internalType: "bytes32", name: "", type: "bytes32" }],
-    name: "positions",
-    outputs: [
-      { internalType: "uint128", name: "liquidity", type: "uint128" },
-      { internalType: "uint256", name: "feeGrowthInside0LastX128", type: "uint256" },
-      { internalType: "uint256", name: "feeGrowthInside1LastX128", type: "uint256" },
-      { internalType: "uint128", name: "tokensOwed0", type: "uint128" },
-      { internalType: "uint128", name: "tokensOwed1", type: "uint128" }
-    ],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [],
-    name: "protocolFees",
-    outputs: [
-      { internalType: "uint128", name: "token0", type: "uint128" },
-      { internalType: "uint128", name: "token1", type: "uint128" }
-    ],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [
-      { internalType: "uint32", name: "feeProtocol0", type: "uint32" },
-      { internalType: "uint32", name: "feeProtocol1", type: "uint32" }
-    ],
-    name: "setFeeProtocol",
-    outputs: [],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    inputs: [{ internalType: "address", name: "_lmPool", type: "address" }],
-    name: "setLmPool",
-    outputs: [],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    inputs: [],
-    name: "slot0",
-    outputs: [
-      { internalType: "uint160", name: "sqrtPriceX96", type: "uint160" },
-      { internalType: "int24", name: "tick", type: "int24" },
-      { internalType: "uint16", name: "observationIndex", type: "uint16" },
-      { internalType: "uint16", name: "observationCardinality", type: "uint16" },
-      { internalType: "uint16", name: "observationCardinalityNext", type: "uint16" },
-      { internalType: "uint32", name: "feeProtocol", type: "uint32" },
-      { internalType: "bool", name: "unlocked", type: "bool" }
-    ],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [
-      { internalType: "int24", name: "tickLower", type: "int24" },
-      { internalType: "int24", name: "tickUpper", type: "int24" }
-    ],
-    name: "snapshotCumulativesInside",
-    outputs: [
-      { internalType: "int56", name: "tickCumulativeInside", type: "int56" },
-      { internalType: "uint160", name: "secondsPerLiquidityInsideX128", type: "uint160" },
-      { internalType: "uint32", name: "secondsInside", type: "uint32" }
-    ],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [
-      { internalType: "address", name: "recipient", type: "address" },
-      { internalType: "bool", name: "zeroForOne", type: "bool" },
-      { internalType: "int256", name: "amountSpecified", type: "int256" },
-      { internalType: "uint160", name: "sqrtPriceLimitX96", type: "uint160" },
-      { internalType: "bytes", name: "data", type: "bytes" }
-    ],
-    name: "swap",
-    outputs: [
-      { internalType: "int256", name: "amount0", type: "int256" },
-      { internalType: "int256", name: "amount1", type: "int256" }
-    ],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    inputs: [{ internalType: "int16", name: "", type: "int16" }],
-    name: "tickBitmap",
-    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [],
-    name: "tickSpacing",
-    outputs: [{ internalType: "int24", name: "", type: "int24" }],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [{ internalType: "int24", name: "", type: "int24" }],
-    name: "ticks",
-    outputs: [
-      { internalType: "uint128", name: "liquidityGross", type: "uint128" },
-      { internalType: "int128", name: "liquidityNet", type: "int128" },
-      { internalType: "uint256", name: "feeGrowthOutside0X128", type: "uint256" },
-      { internalType: "uint256", name: "feeGrowthOutside1X128", type: "uint256" },
-      { internalType: "int56", name: "tickCumulativeOutside", type: "int56" },
-      { internalType: "uint160", name: "secondsPerLiquidityOutsideX128", type: "uint160" },
-      { internalType: "uint32", name: "secondsOutside", type: "uint32" },
-      { internalType: "bool", name: "initialized", type: "bool" }
-    ],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [],
-    name: "token0",
-    outputs: [{ internalType: "address", name: "", type: "address" }],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [],
-    name: "token1",
-    outputs: [{ internalType: "address", name: "", type: "address" }],
-    stateMutability: "view",
-    type: "function"
-  }
-];
-var v3PoolAbi = [
-  {
-    inputs: [],
-    name: "liquidity",
-    outputs: [{ internalType: "uint128", name: "", type: "uint128" }],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [],
-    name: "slot0",
-    outputs: [
-      {
-        internalType: "uint160",
-        name: "sqrtPriceX96",
-        type: "uint160"
-      },
-      {
-        internalType: "int24",
-        name: "tick",
-        type: "int24"
-      },
-      {
-        internalType: "uint16",
-        name: "observationIndex",
-        type: "uint16"
-      },
-      {
-        internalType: "uint16",
-        name: "observationCardinality",
-        type: "uint16"
-      },
-      {
-        internalType: "uint16",
-        name: "observationCardinalityNext",
-        type: "uint16"
-      },
-      {
-        internalType: "uint32",
-        name: "feeProtocol",
-        type: "uint32"
-      },
-      {
-        internalType: "bool",
-        name: "unlocked",
-        type: "bool"
-      }
-    ],
-    stateMutability: "view",
-    type: "function"
-  }
-];
 
 // src/abi/ClassicFactory.json
 var ClassicFactory_default = [
@@ -21710,7 +20786,7 @@ function toCLFeeAmount(_fee) {
   invariant(isCLFeeAmount(_fee), `unsupported CL fee tier: ${_fee}`);
   return _fee;
 }
-function asPancakeFeeAmount(_fee) {
+function toPoolFeeAmount(_fee) {
   return toCLFeeAmount(_fee);
 }
 function getCLTickSpacing(_fee) {
@@ -21721,7 +20797,7 @@ function createCLPool(_params) {
   return new Pool(
     _params.tokenA,
     _params.tokenB,
-    asPancakeFeeAmount(_params.fee),
+    toPoolFeeAmount(_params.fee),
     _params.sqrtRatioX96,
     _params.liquidity,
     _params.tickCurrent,
@@ -21733,17 +20809,10 @@ function computeCLPoolAddress(_params) {
     deployerAddress: _params.config.clPoolDeployer,
     tokenA: _params.tokenA,
     tokenB: _params.tokenB,
-    fee: asPancakeFeeAmount(_params.fee),
+    fee: toPoolFeeAmount(_params.fee),
     initCodeHashManualOverride: _params.config.clInitCodeHash ?? APEX_CL_POOL_INIT_CODE_HASH
   });
 }
-var APEX_CL_TICK_SPACINGS = CL_TICK_SPACINGS;
-var installApexFeeTiers = installCLFeeTiers;
-var isApexCLFeeAmount = isCLFeeAmount;
-var toApexFeeAmount = toCLFeeAmount;
-var getApexTickSpacing = getCLTickSpacing;
-var createApexPool = createCLPool;
-var computeApexCLPoolAddress = computeCLPoolAddress;
 
 // src/classic.ts
 import invariant2 from "tiny-invariant";
@@ -21774,7 +20843,6 @@ function computeClassicPoolAddress(_params) {
     _params.config.classicPairInitCodeHash ?? APEX_CLASSIC_PAIR_INIT_CODE_HASH
   );
 }
-var computeApexClassicPairAddress = computeClassicPoolAddress;
 function quoteClassicExactInput(_params) {
   const tokenIn = normalizeAddress(_params.tokenIn);
   const token0 = normalizeAddress(_params.token0);
@@ -21802,7 +20870,6 @@ function quoteClassicExactInput(_params) {
   invariant2(amountOut > 0n, "INSUFFICIENT_OUTPUT_AMOUNT");
   return amountOut - 1n;
 }
-var quoteApexClassicExactInput = quoteClassicExactInput;
 function getVolatileAmountOut(_params) {
   const reserveA = _params.tokenIn === _params.token0 ? _params.reserve0 : _params.reserve1;
   const reserveB = _params.tokenIn === _params.token0 ? _params.reserve1 : _params.reserve0;
@@ -22098,9 +21165,6 @@ var CLMasterChef = class _CLMasterChef {
     });
   }
 };
-var APEX_MAX_UINT128 = MAX_UINT128;
-var ApexClassicFarm = ClassicChef;
-var ApexCLFarm = CLMasterChef;
 function formatMintParams(_params) {
   return {
     token0: normalizeAddress2(_params.token0),
@@ -22167,9 +21231,9 @@ import invariant4 from "tiny-invariant";
 import { encodePacked as encodePacked3, getAddress as getAddress4, isAddress as isAddress3 } from "viem";
 var APEX_MIXED_ROUTE_CLASSIC_STABLE = 8388608;
 var APEX_MIXED_ROUTE_CLASSIC_VOLATILE = 8388609;
-var APEX_MIXED_ROUTE_PANCAKE_CLASSIC_PLACEHOLDER = APEX_MIXED_ROUTE_CLASSIC_STABLE;
-var APEX_MIXED_ROUTE_PANCAKE_VOLATILE_FLAG = 1;
-var APEX_MIXED_ROUTE_PANCAKE_STABLE_FLAG = 2;
+var APEX_MIXED_ROUTE_CLASSIC_PLACEHOLDER = APEX_MIXED_ROUTE_CLASSIC_STABLE;
+var APEX_MIXED_ROUTE_VOLATILE_FLAG = 1;
+var APEX_MIXED_ROUTE_STABLE_FLAG = 2;
 function encodeMixedRouteToPath(_hops, _exactOutput = false) {
   invariant4(_hops.length > 0, "empty route");
   assertContinuousRoute(_hops);
@@ -22182,7 +21246,7 @@ function encodeMixedRouteToPath(_hops, _exactOutput = false) {
   }
   return encodePacked3(types, values);
 }
-function encodeMixedRouteToPancakeQuoteParams(_hops, _exactOutput = false) {
+function encodeMixedRouteToQuoteParams(_hops, _exactOutput = false) {
   invariant4(_hops.length > 0, "empty route");
   assertContinuousRoute(_hops);
   const hops = _exactOutput ? reverseRoute(_hops) : [..._hops];
@@ -22191,9 +21255,9 @@ function encodeMixedRouteToPancakeQuoteParams(_hops, _exactOutput = false) {
   const flags = [];
   for (const hop of hops) {
     types.push("uint24", "address");
-    values.push(pancakeRouteCode(hop), normalizeAddress3(hop.tokenOut));
-    if (hop.kind === "CLASSIC_STABLE") flags.push(APEX_MIXED_ROUTE_PANCAKE_STABLE_FLAG);
-    if (hop.kind === "CLASSIC_VOLATILE") flags.push(APEX_MIXED_ROUTE_PANCAKE_VOLATILE_FLAG);
+    values.push(quoteRouteCode(hop), normalizeAddress3(hop.tokenOut));
+    if (hop.kind === "CLASSIC_STABLE") flags.push(APEX_MIXED_ROUTE_STABLE_FLAG);
+    if (hop.kind === "CLASSIC_VOLATILE") flags.push(APEX_MIXED_ROUTE_VOLATILE_FLAG);
   }
   return { path: encodePacked3(types, values), flags };
 }
@@ -22241,16 +21305,13 @@ function routeCode(_hop) {
   invariant4(Number.isInteger(_hop.fee) && _hop.fee >= 0 && _hop.fee <= 8388607, "invalid CL fee");
   return _hop.fee;
 }
-function pancakeRouteCode(_hop) {
+function quoteRouteCode(_hop) {
   if (_hop.kind === "CL") {
     invariant4(Number.isInteger(_hop.fee) && _hop.fee >= 0 && _hop.fee <= 8388607, "invalid CL fee");
     return _hop.fee;
   }
-  return APEX_MIXED_ROUTE_PANCAKE_CLASSIC_PLACEHOLDER;
+  return APEX_MIXED_ROUTE_CLASSIC_PLACEHOLDER;
 }
-var encodeApexMixedRouteToPath = encodeMixedRouteToPath;
-var encodeApexMixedRouteToPancakeQuoteParams = encodeMixedRouteToPancakeQuoteParams;
-var decodeApexMixedRoutePath = decodeMixedRoutePath;
 function normalizeAddress3(_address) {
   invariant4(isAddress3(_address), `invalid address: ${_address}`);
   return getAddress4(_address);
@@ -22271,8 +21332,6 @@ function parseProtocolFeePacked(_feeProtocol) {
     token1ProtocolFee: packed / APEX_CL_PROTOCOL_FEE_SPACING
   };
 }
-var packApexProtocolFees = packProtocolFees;
-var parseApexProtocolFeePacked = parseProtocolFeePacked;
 
 // src/smartRouter.ts
 import invariant5 from "tiny-invariant";
@@ -22434,12 +21493,16 @@ var SmartRouter = class _SmartRouter {
     });
   }
 };
-var ApexSmartRouter = SmartRouter;
 function callParameters(_calldatas, _options) {
-  for (const payment of _options.payments ?? []) _calldatas.push(encodePayment(payment));
+  const value = toBigInt3(_options.value ?? 0n);
+  const payments = [..._options.payments ?? []];
+  if (value > 0n && !payments.some((payment) => payment.kind === "REFUND_ETH")) {
+    payments.push({ kind: "REFUND_ETH" });
+  }
+  for (const payment of payments) _calldatas.push(encodePayment(payment));
   return {
     calldata: SmartRouter.encodeMulticall(_calldatas, _options.deadlineOrPreviousBlockhash),
-    value: toHexValue2(_options.value ?? 0n)
+    value: toHexValue2(value)
   };
 }
 function encodePayment(_payment) {
@@ -22473,7 +21536,6 @@ var APEX_VAULT_BPS = 1e4;
 function getApexVaultCompoundBucket(_veNFT) {
   return normalizeAddress5(_veNFT);
 }
-var apexVaultCompoundBucket = getApexVaultCompoundBucket;
 var ApexVault = class _ApexVault {
   constructor() {
   }
@@ -22575,7 +21637,6 @@ var ApexVault = class _ApexVault {
     });
   }
 };
-var ApexVaultPosition = ApexVault;
 function validateApexVaultUserConfig(_config) {
   formatVaultConfig(_config);
 }
@@ -22629,169 +21690,73 @@ function selectFunctionAbi(_abi, _name, _inputCount) {
   return [item];
 }
 export {
-  ADDRESS_ZERO,
   APEX_CLASSIC_FEE_DENOMINATOR,
   APEX_CLASSIC_PAIR_INIT_CODE_HASH,
   APEX_CL_POOL_INIT_CODE_HASH,
   APEX_CL_PROTOCOL_FEE_DENOMINATOR,
   APEX_CL_PROTOCOL_FEE_SPACING,
-  APEX_CL_TICK_SPACINGS,
-  APEX_MAX_UINT128,
+  APEX_MIXED_ROUTE_CLASSIC_PLACEHOLDER,
   APEX_MIXED_ROUTE_CLASSIC_STABLE,
   APEX_MIXED_ROUTE_CLASSIC_VOLATILE,
-  APEX_MIXED_ROUTE_PANCAKE_CLASSIC_PLACEHOLDER,
-  APEX_MIXED_ROUTE_PANCAKE_STABLE_FLAG,
-  APEX_MIXED_ROUTE_PANCAKE_VOLATILE_FLAG,
+  APEX_MIXED_ROUTE_STABLE_FLAG,
+  APEX_MIXED_ROUTE_VOLATILE_FLAG,
   APEX_VAULT_BPS,
-  ApexCLFarm,
-  ApexClassicFarm,
-  CLFeeAmount as ApexFeeAmount,
-  ApexSmartRouter,
   ApexVault,
-  ApexVaultPosition,
   CLFeeAmount,
   CLMasterChef,
   CL_TICK_SPACINGS,
   ClassicChef,
-  DEPLOYER_ADDRESSES,
-  FACTORY_ADDRESSES,
-  FeeAmount,
-  FeeCalculator,
-  FullMath,
-  LiquidityMath,
   MAX_UINT128,
-  MasterChefV3,
-  MaxUint128,
-  Multicall,
-  NFT_POSITION_MANAGER_ADDRESSES,
-  NoTickDataProvider,
   NonfungiblePositionManager,
-  POOL_INIT_CODE_HASHES,
-  Payments,
   Pool,
   Position,
-  PositionLibrary,
-  PositionMath,
   Route,
-  SelfPermit,
   SmartRouter,
-  SqrtPriceMath,
-  Staker,
-  SwapMath,
   SwapQuoter,
   SwapRouter,
-  TICK_SPACINGS,
   Tick,
-  TickLibrary,
-  TickList,
-  TickListDataProvider,
   TickMath,
   Trade,
   apexControllerAbi,
   apexTokenAbi,
   apexVaultAbi,
-  apexVaultCompoundBucket,
-  asPancakeFeeAmount,
   clFactoryAbi,
   clMasterChefAbi,
   clPoolAbi,
   classicChefAbi,
   classicFactoryAbi,
   classicPoolAbi,
-  computeApexCLPoolAddress,
-  computeApexClassicPairAddress,
   computeCLPoolAddress,
   computeClassicPoolAddress,
   computeCreate2Address,
-  computePoolAddress,
-  createApexPool,
   createCLPool,
-  decodeApexMixedRoutePath,
   decodeMixedRoutePath,
-  encodeApexMixedRouteToPancakeQuoteParams,
-  encodeApexMixedRouteToPath,
-  encodeMixedRouteToPancakeQuoteParams,
   encodeMixedRouteToPath,
-  encodeRouteToPath,
+  encodeMixedRouteToQuoteParams,
   encodeSqrtRatioX96,
   feeCenterAbi,
   feeReceiverAbi,
   feeSwapperAbi,
   formatVaultConfig,
-  getAmountsAtNewPrice,
-  getAmountsByLiquidityAndPrice,
-  getApexTickSpacing,
   getApexVaultCompoundBucket,
-  getAverageLiquidity,
   getCLTickSpacing,
-  getCurrency0Price,
-  getCurrency1Price,
-  getDependentAmount,
-  getEstimatedLPFee,
-  getEstimatedLPFeeByAmounts,
-  getEstimatedLPFeeByAmountsWithProtocolFee,
-  getEstimatedLPFeeWithProtocolFee,
-  getInputAmount,
-  getLiquidityByAmountsAndPrice,
-  getLiquidityBySingleAmount,
-  getLiquidityFromSqrtRatioX96,
-  getLiquidityFromTick,
-  getOutputAmount,
-  getPool,
-  getPriceOfCurrency,
-  getPriceOfCurrency0,
-  getPriceOfCurrency1,
-  hasInvolvedCurrency,
-  installApexFeeTiers,
   installCLFeeTiers,
   interfaceMulticallAbi,
-  isApexCLFeeAmount,
   isCLFeeAmount,
-  isMint,
-  isPoolTickInRange,
-  isSorted,
-  masterChefV3ABI,
-  maxLiquidityForAmount0Imprecise,
-  maxLiquidityForAmount0Precise,
-  maxLiquidityForAmount1,
-  maxLiquidityForAmounts,
   mixedQuoterAbi,
-  mostSignificantBit,
   nearestUsableTick,
-  nonfungiblePositionManagerABI,
   nonfungiblePositionManagerAbi,
   normalizeAddress,
-  packApexProtocolFees,
   packProtocolFees,
-  pancakeV3PoolABI,
-  parseApexProtocolFeePacked,
   parseProtocolFeePacked,
-  parseProtocolFees,
-  peripheryPaymentsWithFeeABI,
-  priceToClosestTick,
-  quoteApexClassicExactInput,
   quoteClassicExactInput,
-  quoterABI,
   quoterAbi,
-  quoterV2ABI,
   quoterV2Abi,
-  selfPermitABI,
   smartRouterAbi,
   sortAddresses,
-  sqrtRatioX96ToPrice,
-  subIn256,
-  swap,
-  swapRouterABI,
   swapRouterAbi,
   tickLensAbi,
-  tickToPrice,
-  tickToPriceV2,
-  toApexFeeAmount,
   toCLFeeAmount,
-  toHex,
-  tradeComparator,
-  v3PoolAbi,
-  v3StakerABI,
   validateApexVaultUserConfig,
   veApexTokenAbi
 };