@guru-fund/sdk 0.1.0

package/dist/router/poolHelper.js

@@ -0,0 +1,807 @@
+import { Contract, ZeroAddress, solidityPacked, } from 'ethers';
+import { getGuruProtocolAddresses, isSupportedChainId, } from '../addresses.js';
+import compareAddresses from '../helpers/compareAddresses.js';
+import { Token } from '../helpers/Token.js';
+import { AerodromeV2Adapter__factory, IPancakeQuoterV2__factory, UniswapV2Adapter__factory, UniswapV3Adapter__factory, } from '../typechain/index.js';
+import { finalizeRouteQuote } from './finalizeRoute.js';
+export const SwapType = Object.freeze({
+    EXACT_INPUT: 0n,
+    EXACT_OUTPUT: 1n,
+});
+const V2_ROUTER_ABI = [
+    'function getAmountsOut(uint256 amountIn, address[] path) view returns (uint256[] amounts)',
+    'function getAmountsIn(uint256 amountOut, address[] path) view returns (uint256[] amounts)',
+];
+const V2_FACTORY_ABI = [
+    'function getPair(address tokenA, address tokenB) view returns (address pair)',
+];
+const V2_PAIR_ABI = [
+    'function getReserves() view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast)',
+];
+const V3_FACTORY_ABI = [
+    'function getPool(address tokenA, address tokenB, uint24 fee) view returns (address pool)',
+];
+const V3_POOL_ABI = ['function fee() view returns (uint24)'];
+const AERO_FACTORY_ABI = [
+    'function getPool(address tokenA, address tokenB, bool stable) view returns (address)',
+];
+const AERO_V2_ROUTER_ABI = [
+    'function getAmountsOut(uint256 amountIn, (address from, address to, bool stable, address factory)[] routes) view returns (uint256[] amounts)',
+];
+const AERO_V3_QUOTER_ABI = [
+    'function quoteExactInputSingle((address tokenIn, address tokenOut, uint256 amountIn, int24 tickSpacing, uint160 sqrtPriceLimitX96) params) returns (uint256 amountOut, uint160 sqrtPriceX96After, uint32 initializedTicksCrossed, uint256 gasEstimate)',
+    'function quoteExactOutputSingle((address tokenIn, address tokenOut, uint256 amount, int24 tickSpacing, uint160 sqrtPriceLimitX96) params) returns (uint256 amountIn, uint160 sqrtPriceX96After, uint32 initializedTicksCrossed, uint256 gasEstimate)',
+];
+const V3_POOL_TICKSPACING_ABI = [
+    'function tickSpacing() view returns (int24)',
+];
+function connect(address, abi, runner) {
+    return new Contract(address, abi, runner);
+}
+var PoolHelperError;
+(function (PoolHelperError) {
+    PoolHelperError["NO_ROUTE_FOUND"] = "NO_ROUTE_FOUND";
+    PoolHelperError["NETWORK_NOT_SUPPORTED"] = "NETWORK_NOT_SUPPORTED";
+    PoolHelperError["EXCHANGE_INCOMPATIBLE"] = "EXCHANGE_INCOMPATIBLE";
+    PoolHelperError["NO_POOL_ADDRESS"] = "NO_POOL_ADDRESS";
+    PoolHelperError["LOTUS_ADAPTER_MISSING"] = "LOTUS_ADAPTER_MISSING";
+})(PoolHelperError || (PoolHelperError = {}));
+const UNIV3_FEE_TIERS = [100, 500, 3000, 10000];
+const PANCAKEV3_FEE_TIERS = [100, 500, 2500, 10000];
+const AEROV3_FEE_TIERS = [1, 50, 100, 200];
+function buildDexTable(addresses) {
+    const table = {};
+    if (addresses.factories.uniswapV2 && addresses.routers.uniswapV2) {
+        table[addresses.factories.uniswapV2.toLowerCase()] = {
+            type: 'v2',
+            router: addresses.routers.uniswapV2,
+            kind: 'uniswap',
+            swappable: Boolean(addresses.adapters.uniswapV2),
+        };
+    }
+    if (addresses.factories.uniswapV3 && addresses.quoters.uniswapV3) {
+        table[addresses.factories.uniswapV3.toLowerCase()] = {
+            type: 'v3',
+            router: addresses.routers.uniswapV3,
+            quoter: addresses.quoters.uniswapV3,
+            feeTiers: UNIV3_FEE_TIERS,
+            kind: 'uniswap',
+            swappable: Boolean(addresses.adapters.uniswapV3),
+        };
+    }
+    if (addresses.factories.pancakeV2 && addresses.routers.pancakeV2) {
+        table[addresses.factories.pancakeV2.toLowerCase()] = {
+            type: 'v2',
+            router: addresses.routers.pancakeV2,
+            kind: 'uniswap',
+            swappable: Boolean(addresses.adapters.pancakeV2),
+        };
+    }
+    if (addresses.factories.pancakeV3 && addresses.quoters.pancakeV3) {
+        table[addresses.factories.pancakeV3.toLowerCase()] = {
+            type: 'v3',
+            router: addresses.routers.pancakeV3,
+            quoter: addresses.quoters.pancakeV3,
+            feeTiers: PANCAKEV3_FEE_TIERS,
+            kind: 'uniswap',
+            swappable: Boolean(addresses.adapters.pancakeV3),
+        };
+    }
+    if (addresses.factories.aerodromeV2 && addresses.routers.aerodromeV2) {
+        table[addresses.factories.aerodromeV2.toLowerCase()] = {
+            type: 'v2',
+            router: addresses.routers.aerodromeV2,
+            kind: 'aerodrome',
+            swappable: Boolean(addresses.adapters.aerodromeV2),
+        };
+    }
+    if (addresses.factories.aerodromeV3 && addresses.quoters.aerodromeV3) {
+        const v3 = {
+            type: 'v3',
+            router: addresses.routers.aerodromeV3,
+            quoter: addresses.quoters.aerodromeV3,
+            feeTiers: AEROV3_FEE_TIERS,
+            kind: 'aerodrome',
+            swappable: Boolean(addresses.adapters.aerodromeV3),
+        };
+        table[addresses.factories.aerodromeV3.toLowerCase()] = v3;
+        if (addresses.factories.aerodromeV3Bis) {
+            table[addresses.factories.aerodromeV3Bis.toLowerCase()] = v3;
+        }
+    }
+    return table;
+}
+const PERCENT_DENOMINATOR = 100000n;
+const CACHE_DURATION = 60 * 60 * 1000;
+function withSlippageTolerance(amount, slippage) {
+    const tolerance = (amount * slippage) / PERCENT_DENOMINATOR;
+    return amount - tolerance;
+}
+function calcSlippageTolerance(amount, slippage) {
+    return (amount * slippage) / PERCENT_DENOMINATOR;
+}
+function lastAmount(amounts, context) {
+    const amount = amounts.at(-1);
+    if (amount == null) {
+        throw new Error(`${PoolHelperError.NO_ROUTE_FOUND}: empty quote (${context})`);
+    }
+    return amount;
+}
+function buildAerodromeV2Routes(path, factory) {
+    return path.slice(0, -1).map((token, i) => ({
+        from: token,
+        to: path[i + 1],
+        stable: false,
+        factory,
+    }));
+}
+export default class PoolHelper {
+    chainId;
+    addresses;
+    provider;
+    getSwapFeePercentage;
+    dexTable;
+    poolsCache = {};
+    constructor(config) {
+        if (!isSupportedChainId(config.chainId)) {
+            throw new Error(`${PoolHelperError.NETWORK_NOT_SUPPORTED}: chainId=${config.chainId}`);
+        }
+        this.chainId = config.chainId;
+        this.addresses = getGuruProtocolAddresses(config.chainId);
+        this.provider = config.provider;
+        this.getSwapFeePercentage = config.getSwapFeePercentage;
+        this.dexTable = buildDexTable(this.addresses);
+    }
+    async _finalizeExecutableQuote({ finalization, adapter, path, amountToSend, amountQuoted, initialTollAmount, outputTollE3, slippage, buildSwap, }) {
+        if (!finalization) {
+            const amountToReceive = withSlippageTolerance(amountQuoted, slippage);
+            const tollAmount = initialTollAmount === 0n
+                ? (amountToReceive * (outputTollE3 ?? 200n)) /
+                    PERCENT_DENOMINATOR
+                : initialTollAmount;
+            const swap = buildSwap(amountToReceive);
+            return { ...swap, tollAmount };
+        }
+        const context = {
+            chainId: this.chainId,
+            blockNumber: finalization.blockNumber,
+            controller: finalization.controller,
+            vault: finalization.vault,
+            adapter,
+            account: finalization.account,
+            path,
+            buildCallDataForAmount: (amountToReceive) => String(buildSwap(amountToReceive).callData),
+            simulator: finalization.simulator,
+            prefixTxs: finalization.prefixTxs,
+        };
+        const result = await finalizeRouteQuote({
+            context,
+            amountToSend,
+            amountQuoted,
+            initialTollAmount,
+            outputTollE3,
+            maxSlippageE3: finalization.maxSlippageE3 ?? slippage,
+        });
+        const { data } = buildSwap(result.finalAmountToReceive);
+        return {
+            data,
+            callData: result.callData,
+            tollAmount: result.finalTollAmount,
+            effectiveSlippageBps: result.effectiveSlippageBps,
+        };
+    }
+    getDexData(exchangeFactory) {
+        const dex = this.dexTable[exchangeFactory.toLowerCase()];
+        if (!dex) {
+            throw new Error(`${PoolHelperError.EXCHANGE_INCOMPATIBLE}: factory=${exchangeFactory} chainId=${this.chainId}`);
+        }
+        return dex;
+    }
+    isAerodrome(exchangeFactory) {
+        const dex = this.dexTable[exchangeFactory.toLowerCase()];
+        return dex?.kind === 'aerodrome';
+    }
+    async getPoolFeeTier(poolAddress) {
+        try {
+            const pool = connect(poolAddress, V3_POOL_ABI, this.provider);
+            const feeTier = await pool.fee();
+            return Number(feeTier);
+        }
+        catch {
+            try {
+                const pair = connect(poolAddress, V2_PAIR_ABI, this.provider);
+                await pair.getReserves();
+                return 0;
+            }
+            catch {
+                throw new Error(`${PoolHelperError.EXCHANGE_INCOMPATIBLE}: poolAddress=${poolAddress}`);
+            }
+        }
+    }
+    async _getPoolsFromOnChainQuery(token, options = {}) {
+        const { exchangeFactory, swappableOnly } = options;
+        const weth = this.addresses.tokens.WETH;
+        const wethToken = new Token(weth, this.provider);
+        const entries = Object.entries(this.dexTable).filter(([factory, dex]) => {
+            if (exchangeFactory &&
+                !compareAddresses(exchangeFactory, factory)) {
+                return false;
+            }
+            if (swappableOnly && !dex.swappable)
+                return false;
+            return true;
+        });
+        const pools = [];
+        await Promise.all(entries.map(async ([factoryAddress, dex]) => {
+            if (dex.type === 'v2') {
+                try {
+                    let pairAddress;
+                    if (dex.kind === 'aerodrome') {
+                        const aeroFactory = connect(factoryAddress, AERO_FACTORY_ABI, this.provider);
+                        pairAddress = await aeroFactory.getPool(token, weth, false);
+                    }
+                    else {
+                        const factory = connect(factoryAddress, V2_FACTORY_ABI, this.provider);
+                        pairAddress = await factory.getPair(token, weth);
+                    }
+                    if (pairAddress === ZeroAddress)
+                        return;
+                    const wethBalance = await wethToken.balanceOf(pairAddress);
+                    if (wethBalance === 0n)
+                        return;
+                    pools.push({
+                        address: pairAddress,
+                        feeTier: 0,
+                        exchangeFactory: factoryAddress,
+                        wethBalance,
+                    });
+                }
+                catch {
+                }
+            }
+            else {
+                const factory = connect(factoryAddress, V3_FACTORY_ABI, this.provider);
+                await Promise.all(dex.feeTiers.map(async (feeTier) => {
+                    try {
+                        const poolAddress = await factory.getPool(token, weth, feeTier);
+                        if (poolAddress === ZeroAddress)
+                            return;
+                        const wethBalance = await wethToken.balanceOf(poolAddress);
+                        if (wethBalance === 0n)
+                            return;
+                        pools.push({
+                            address: poolAddress,
+                            feeTier: feeTier,
+                            exchangeFactory: factoryAddress,
+                            wethBalance,
+                        });
+                    }
+                    catch {
+                    }
+                }));
+            }
+        }));
+        pools.sort((a, b) => {
+            if (a.wethBalance > b.wethBalance)
+                return -1;
+            if (a.wethBalance < b.wethBalance)
+                return 1;
+            return 0;
+        });
+        return pools;
+    }
+    async getUniswapCompatibleTokenPools(token, options) {
+        const swappableOnly = options?.swappableOnly ?? true;
+        const cacheKey = `onchain-${this.chainId}-${token.toLowerCase()}-${options?.exchangeFactory?.toLowerCase()}-${swappableOnly}`;
+        const hit = this.poolsCache[cacheKey];
+        if (!hit || Date.now() - hit.timestamp > CACHE_DURATION) {
+            this.poolsCache[cacheKey] = {
+                timestamp: Date.now(),
+                pools: await this._getPoolsFromOnChainQuery(token, {
+                    exchangeFactory: options?.exchangeFactory,
+                    swappableOnly,
+                }),
+            };
+        }
+        return this.poolsCache[cacheKey].pools;
+    }
+    async getUniswapCompatibleTokenPool(token, options) {
+        const pools = await this.getUniswapCompatibleTokenPools(token, options);
+        if (pools.length === 0) {
+            throw new Error(`${PoolHelperError.NO_ROUTE_FOUND}: token=${token}`);
+        }
+        return pools[0];
+    }
+    async getBestQuote({ swapType = SwapType.EXACT_INPUT, tokenAmount, slippage = 500n, path, requireSwappable = true, }) {
+        const weth = this.addresses.tokens.WETH;
+        if (!path.some((t) => compareAddresses(t, weth))) {
+            throw new Error(`${PoolHelperError.NO_ROUTE_FOUND}: WETH not in path`);
+        }
+        const token = path.find((t) => !compareAddresses(t, weth));
+        const pools = await this.getUniswapCompatibleTokenPools(token, {
+            swappableOnly: requireSwappable,
+        });
+        if (pools.length === 0) {
+            throw new Error(`${PoolHelperError.NO_ROUTE_FOUND}: token=${token}`);
+        }
+        let lastError;
+        for (const pool of pools) {
+            const isV2Pool = pool.feeTier === 0;
+            const getQuote = isV2Pool ? this.getV2Quote : this.getV3Quote;
+            try {
+                return await getQuote.call(this, {
+                    swapType,
+                    tokenAmount,
+                    path,
+                    slippage,
+                    exchangeFactory: pool.exchangeFactory,
+                    feeTier: pool.feeTier,
+                    poolAddress: pool.address,
+                });
+            }
+            catch (err) {
+                lastError = err;
+            }
+        }
+        throw lastError instanceof Error
+            ? lastError
+            : new Error(`${PoolHelperError.NO_ROUTE_FOUND}: token=${token}`);
+    }
+    async getV2Quote({ swapType = SwapType.EXACT_INPUT, tokenAmount, exchangeFactory, path, feeTier, slippage, }) {
+        const dex = this.getDexData(exchangeFactory);
+        if (dex.type !== 'v2') {
+            throw new Error(`${PoolHelperError.EXCHANGE_INCOMPATIBLE}: factory=${exchangeFactory}`);
+        }
+        const swapFeePercentage = await this.getSwapFeePercentage();
+        const { adjustedTokenAmount, swapFee: swapFeeFromInputAdjustment } = this._adjustTokenAmountForSwapFee(tokenAmount, swapFeePercentage, swapType, path);
+        const getAmounts = () => {
+            if (dex.kind === 'aerodrome') {
+                const v2Router = connect(dex.router, AERO_V2_ROUTER_ABI, this.provider);
+                const _path = swapType === SwapType.EXACT_INPUT
+                    ? path
+                    : [...path].reverse();
+                const routes = [
+                    {
+                        from: _path[0],
+                        to: _path[1],
+                        stable: false,
+                        factory: exchangeFactory,
+                    },
+                ];
+                return v2Router.getAmountsOut(adjustedTokenAmount, routes);
+            }
+            const v2Router = connect(dex.router, V2_ROUTER_ABI, this.provider);
+            return swapType === SwapType.EXACT_INPUT
+                ? v2Router.getAmountsOut(adjustedTokenAmount, path)
+                : v2Router.getAmountsIn(adjustedTokenAmount, path);
+        };
+        const amounts = await getAmounts();
+        const quotedInput = amounts[0];
+        if (quotedInput == null) {
+            throw new Error(`${PoolHelperError.NO_ROUTE_FOUND}: empty quote (${exchangeFactory})`);
+        }
+        const quotedOutput = lastAmount(amounts, exchangeFactory);
+        const { adjustedQuote, swapFee: swapFeeFromQuoteAdjustment } = this._adjustQuoteForSwapFeeAndSlippage(swapType === SwapType.EXACT_INPUT ? quotedOutput : quotedInput, swapFeePercentage, slippage, swapType, path);
+        return {
+            amount: adjustedQuote,
+            feeTier,
+            swapFee: swapFeeFromInputAdjustment + swapFeeFromQuoteAdjustment,
+            router: dex.router,
+            exchangeFactory,
+        };
+    }
+    async getV3Quote({ swapType = SwapType.EXACT_INPUT, tokenAmount, exchangeFactory, path, feeTier, slippage, poolAddress, }) {
+        const [$INPUT, $OUTPUT] = path;
+        const dex = this.getDexData(exchangeFactory);
+        if (dex.type !== 'v3') {
+            throw new Error(`${PoolHelperError.EXCHANGE_INCOMPATIBLE}: factory=${exchangeFactory}`);
+        }
+        const swapFeePercentage = await this.getSwapFeePercentage();
+        const { adjustedTokenAmount, swapFee: swapFeeFromInputAdjustment } = this._adjustTokenAmountForSwapFee(tokenAmount, swapFeePercentage, swapType, path);
+        let tickSpacing;
+        let getQuote;
+        if (dex.kind === 'aerodrome') {
+            if (!poolAddress) {
+                throw new Error(`${PoolHelperError.NO_POOL_ADDRESS}: factory=${exchangeFactory}`);
+            }
+            const poolContract = connect(poolAddress, V3_POOL_TICKSPACING_ABI, this.provider);
+            const _tickSpacing = await poolContract.tickSpacing();
+            tickSpacing = _tickSpacing;
+            const aerodromeQuoter = connect(dex.quoter, AERO_V3_QUOTER_ABI, this.provider);
+            if (swapType === SwapType.EXACT_INPUT) {
+                getQuote = async () => {
+                    const result = await aerodromeQuoter.quoteExactInputSingle.staticCall({
+                        tokenIn: $INPUT,
+                        tokenOut: $OUTPUT,
+                        amountIn: adjustedTokenAmount,
+                        sqrtPriceLimitX96: 0n,
+                        tickSpacing: _tickSpacing,
+                    });
+                    return result.amountOut;
+                };
+            }
+            else {
+                getQuote = async () => {
+                    const result = await aerodromeQuoter.quoteExactOutputSingle.staticCall({
+                        tokenIn: $INPUT,
+                        tokenOut: $OUTPUT,
+                        amount: adjustedTokenAmount,
+                        sqrtPriceLimitX96: 0n,
+                        tickSpacing: _tickSpacing,
+                    });
+                    return result.amountIn;
+                };
+            }
+        }
+        else {
+            const v3Quoter = IPancakeQuoterV2__factory.connect(dex.quoter, this.provider);
+            const quoteRequest = {
+                tokenIn: $INPUT,
+                tokenOut: $OUTPUT,
+                fee: BigInt(feeTier),
+                sqrtPriceLimitX96: 0n,
+            };
+            if (swapType === SwapType.EXACT_INPUT) {
+                getQuote = async () => {
+                    const [amountOut] = await v3Quoter.quoteExactInputSingle.staticCall({
+                        ...quoteRequest,
+                        amountIn: adjustedTokenAmount,
+                    });
+                    return amountOut;
+                };
+            }
+            else {
+                getQuote = async () => {
+                    const [amountIn] = await v3Quoter.quoteExactOutputSingle.staticCall({
+                        ...quoteRequest,
+                        amount: adjustedTokenAmount,
+                    });
+                    return amountIn;
+                };
+            }
+        }
+        const quote = await getQuote();
+        const { adjustedQuote, swapFee: swapFeeFromQuoteAdjustment } = this._adjustQuoteForSwapFeeAndSlippage(quote, swapFeePercentage, slippage, swapType, path);
+        return {
+            amount: adjustedQuote,
+            feeTier,
+            swapFee: swapFeeFromInputAdjustment + swapFeeFromQuoteAdjustment,
+            router: dex.router ?? dex.quoter,
+            exchangeFactory,
+            poolAddress,
+            tickSpacing,
+        };
+    }
+    async getStableForTokenQuote({ path, inputAmount, slippage = 500n, exchangeFactory, finalization, }) {
+        const adapter = this.getLotusAdapter(exchangeFactory);
+        const dexData = this.getDexData(exchangeFactory);
+        const swapFeePercentage = await this.getSwapFeePercentage();
+        const swapFee = (inputAmount * swapFeePercentage) / PERCENT_DENOMINATOR;
+        const adjustedInputAmount = inputAmount - swapFee;
+        if (dexData.type === 'v2') {
+            const deadline = Math.floor((Date.now() + 1000 * 60 * 5) / 1000);
+            if (dexData.kind === 'aerodrome') {
+                const v2Router = connect(dexData.router, AERO_V2_ROUTER_ABI, this.provider);
+                const routes = buildAerodromeV2Routes(path, exchangeFactory);
+                const amounts = await v2Router.getAmountsOut(adjustedInputAmount, routes);
+                const finalized = await this._finalizeExecutableQuote({
+                    finalization,
+                    adapter,
+                    path,
+                    amountToSend: inputAmount,
+                    amountQuoted: lastAmount(amounts, exchangeFactory),
+                    initialTollAmount: swapFee,
+                    slippage,
+                    buildSwap: (amountToReceive) => {
+                        const data = {
+                            amountToSend: inputAmount,
+                            amountToReceive,
+                            routes,
+                            deadline,
+                        };
+                        return {
+                            data,
+                            callData: AerodromeV2Adapter__factory.createInterface().encodeFunctionData('executeSwap', [data]),
+                        };
+                    },
+                });
+                return {
+                    adapter,
+                    data: finalized.data,
+                    callData: finalized.callData,
+                    toll: { currency: path[0], amount: finalized.tollAmount },
+                    effectiveSlippageBps: finalized.effectiveSlippageBps,
+                };
+            }
+            const v2Router = connect(dexData.router, V2_ROUTER_ABI, this.provider);
+            const amounts = await v2Router.getAmountsOut(adjustedInputAmount, path);
+            const finalized = await this._finalizeExecutableQuote({
+                finalization,
+                adapter,
+                path,
+                amountToSend: inputAmount,
+                amountQuoted: lastAmount(amounts, exchangeFactory),
+                initialTollAmount: swapFee,
+                slippage,
+                buildSwap: (amountToReceive) => {
+                    const data = {
+                        amountToSend: inputAmount,
+                        amountToReceive,
+                        path,
+                        deadline,
+                    };
+                    return {
+                        data,
+                        callData: UniswapV2Adapter__factory.createInterface().encodeFunctionData('executeSwap', [data]),
+                    };
+                },
+            });
+            return {
+                adapter,
+                data: finalized.data,
+                callData: finalized.callData,
+                toll: { currency: path[0], amount: finalized.tollAmount },
+                effectiveSlippageBps: finalized.effectiveSlippageBps,
+            };
+        }
+        const quoter = dexData.kind === 'aerodrome'
+            ? connect(dexData.quoter, AERO_V3_QUOTER_ABI, this.provider)
+            : IPancakeQuoterV2__factory.connect(dexData.quoter, this.provider);
+        const { feeTier: stableFeeTier } = await this.getUniswapCompatibleTokenPool(path[0], {
+            exchangeFactory,
+        });
+        const { feeTier: tokenFeeTier } = await this.getUniswapCompatibleTokenPool(path[2], {
+            exchangeFactory,
+        });
+        const pathBytes = solidityPacked(['address', 'uint24', 'address', 'uint24', 'address'], [path[0], stableFeeTier, path[1], tokenFeeTier, path[2]]);
+        if (dexData.kind === 'aerodrome') {
+            throw new Error(`${PoolHelperError.EXCHANGE_INCOMPATIBLE}: Aerodrome V3 multi-hop not supported (factory=${exchangeFactory})`);
+        }
+        const univ3Quoter = quoter;
+        const amountOut = await this._quoteV3MultiHop(univ3Quoter, adjustedInputAmount, pathBytes, [
+            { tokenIn: path[0], tokenOut: path[1], fee: stableFeeTier },
+            { tokenIn: path[1], tokenOut: path[2], fee: tokenFeeTier },
+        ]);
+        const deadline = Math.floor((Date.now() + 1000 * 60 * 5) / 1000);
+        const finalized = await this._finalizeExecutableQuote({
+            finalization,
+            adapter,
+            path: [
+                {
+                    tokenIn: path[0],
+                    tokenOut: path[1],
+                    fee: String(stableFeeTier),
+                },
+                {
+                    tokenIn: path[1],
+                    tokenOut: path[2],
+                    fee: String(tokenFeeTier),
+                },
+            ],
+            amountToSend: inputAmount,
+            amountQuoted: amountOut,
+            initialTollAmount: swapFee,
+            slippage,
+            buildSwap: (amountToReceive) => {
+                const data = {
+                    amountToSend: inputAmount,
+                    amountToReceive,
+                    path: pathBytes,
+                    deadline,
+                };
+                return {
+                    data,
+                    callData: UniswapV3Adapter__factory.createInterface().encodeFunctionData('executeSwap', [data]),
+                };
+            },
+        });
+        return {
+            adapter,
+            data: finalized.data,
+            callData: finalized.callData,
+            toll: { currency: path[0], amount: finalized.tollAmount },
+            effectiveSlippageBps: finalized.effectiveSlippageBps,
+        };
+    }
+    async _quoteV3MultiHop(quoter, amountIn, pathBytes, legs) {
+        try {
+            const r = await quoter.quoteExactInput.staticCall(pathBytes, amountIn);
+            return r.amountOut;
+        }
+        catch {
+            let amount = amountIn;
+            for (const leg of legs) {
+                const [out] = await quoter.quoteExactInputSingle.staticCall({
+                    tokenIn: leg.tokenIn,
+                    tokenOut: leg.tokenOut,
+                    fee: BigInt(leg.fee),
+                    amountIn: amount,
+                    sqrtPriceLimitX96: 0n,
+                });
+                amount = out;
+            }
+            return amount;
+        }
+    }
+    async getTokensForStableQuote({ path, inputAmount, slippage = 500n, exchangeFactory, finalization, }) {
+        const adapter = this.getLotusAdapter(exchangeFactory);
+        const dexData = this.getDexData(exchangeFactory);
+        const swapFeePercentage = await this.getSwapFeePercentage();
+        if (dexData.type === 'v2') {
+            const deadline = Math.floor((Date.now() + 1000 * 60 * 5) / 1000);
+            if (dexData.kind === 'aerodrome') {
+                const v2Router = connect(dexData.router, AERO_V2_ROUTER_ABI, this.provider);
+                const routes = buildAerodromeV2Routes(path, exchangeFactory);
+                const amounts = await v2Router.getAmountsOut(inputAmount, routes);
+                const grossAmountOut = lastAmount(amounts, exchangeFactory);
+                const netAmountOut = grossAmountOut -
+                    (grossAmountOut * swapFeePercentage) / PERCENT_DENOMINATOR;
+                const finalized = await this._finalizeExecutableQuote({
+                    finalization,
+                    adapter,
+                    path,
+                    amountToSend: inputAmount,
+                    amountQuoted: netAmountOut,
+                    initialTollAmount: 0n,
+                    outputTollE3: swapFeePercentage,
+                    slippage,
+                    buildSwap: (amountToReceive) => {
+                        const data = {
+                            amountToSend: inputAmount,
+                            amountToReceive,
+                            routes,
+                            deadline,
+                        };
+                        return {
+                            data,
+                            callData: AerodromeV2Adapter__factory.createInterface().encodeFunctionData('executeSwap', [data]),
+                        };
+                    },
+                });
+                return {
+                    adapter,
+                    data: finalized.data,
+                    callData: finalized.callData,
+                    toll: { currency: path[2], amount: finalized.tollAmount },
+                    effectiveSlippageBps: finalized.effectiveSlippageBps,
+                };
+            }
+            const v2Router = connect(dexData.router, V2_ROUTER_ABI, this.provider);
+            const amounts = await v2Router.getAmountsOut(inputAmount, path);
+            const grossAmountOut = lastAmount(amounts, exchangeFactory);
+            const netAmountOut = grossAmountOut -
+                (grossAmountOut * swapFeePercentage) / PERCENT_DENOMINATOR;
+            const finalized = await this._finalizeExecutableQuote({
+                finalization,
+                adapter,
+                path,
+                amountToSend: inputAmount,
+                amountQuoted: netAmountOut,
+                initialTollAmount: 0n,
+                outputTollE3: swapFeePercentage,
+                slippage,
+                buildSwap: (amountToReceive) => {
+                    const data = {
+                        amountToSend: inputAmount,
+                        amountToReceive,
+                        path,
+                        deadline,
+                    };
+                    return {
+                        data,
+                        callData: UniswapV2Adapter__factory.createInterface().encodeFunctionData('executeSwap', [data]),
+                    };
+                },
+            });
+            return {
+                adapter,
+                data: finalized.data,
+                callData: finalized.callData,
+                toll: { currency: path[2], amount: finalized.tollAmount },
+                effectiveSlippageBps: finalized.effectiveSlippageBps,
+            };
+        }
+        if (dexData.kind === 'aerodrome') {
+            throw new Error(`${PoolHelperError.EXCHANGE_INCOMPATIBLE}: Aerodrome V3 multi-hop not supported (factory=${exchangeFactory})`);
+        }
+        const v3Quoter = IPancakeQuoterV2__factory.connect(dexData.quoter, this.provider);
+        const { feeTier: tokenFeeTier } = await this.getUniswapCompatibleTokenPool(path[0], {
+            exchangeFactory,
+        });
+        const { feeTier: stableFeeTier } = await this.getUniswapCompatibleTokenPool(path[2], {
+            exchangeFactory,
+        });
+        const pathBytes = solidityPacked(['address', 'uint24', 'address', 'uint24', 'address'], [path[0], tokenFeeTier, path[1], stableFeeTier, path[2]]);
+        const amountOut = await this._quoteV3MultiHop(v3Quoter, inputAmount, pathBytes, [
+            { tokenIn: path[0], tokenOut: path[1], fee: tokenFeeTier },
+            { tokenIn: path[1], tokenOut: path[2], fee: stableFeeTier },
+        ]);
+        const deadline = Math.floor((Date.now() + 1000 * 60 * 5) / 1000);
+        const netAmountOut = amountOut - (amountOut * swapFeePercentage) / PERCENT_DENOMINATOR;
+        const finalized = await this._finalizeExecutableQuote({
+            finalization,
+            adapter,
+            path: [
+                {
+                    tokenIn: path[0],
+                    tokenOut: path[1],
+                    fee: String(tokenFeeTier),
+                },
+                {
+                    tokenIn: path[1],
+                    tokenOut: path[2],
+                    fee: String(stableFeeTier),
+                },
+            ],
+            amountToSend: inputAmount,
+            amountQuoted: netAmountOut,
+            initialTollAmount: 0n,
+            outputTollE3: swapFeePercentage,
+            slippage,
+            buildSwap: (amountToReceive) => {
+                const data = {
+                    amountToSend: inputAmount,
+                    amountToReceive,
+                    path: pathBytes,
+                    deadline,
+                };
+                return {
+                    data,
+                    callData: UniswapV3Adapter__factory.createInterface().encodeFunctionData('executeSwap', [data]),
+                };
+            },
+        });
+        return {
+            adapter,
+            data: finalized.data,
+            callData: finalized.callData,
+            toll: { currency: path[2], amount: finalized.tollAmount },
+            effectiveSlippageBps: finalized.effectiveSlippageBps,
+        };
+    }
+    getLotusAdapter(exchangeFactory) {
+        const factoryLower = exchangeFactory.toLowerCase();
+        const f = this.addresses.factories;
+        const a = this.addresses.adapters;
+        const adapter = [
+            [f.uniswapV2, a.uniswapV2],
+            [f.uniswapV3, a.uniswapV3],
+            [f.pancakeV2, a.pancakeV2],
+            [f.pancakeV3, a.pancakeV3],
+            [f.aerodromeV2, a.aerodromeV2],
+            [f.aerodromeV3, a.aerodromeV3],
+            [f.aerodromeV3Bis, a.aerodromeV3],
+        ].find(([factory]) => factory && factory.toLowerCase() === factoryLower)?.[1];
+        if (!adapter) {
+            throw new Error(`${PoolHelperError.LOTUS_ADAPTER_MISSING}: factory=${exchangeFactory} chainId=${this.chainId}`);
+        }
+        return adapter;
+    }
+    _adjustTokenAmountForSwapFee(tokenAmount, swapFeePercentage, swapType, path) {
+        const weth = this.addresses.tokens.WETH;
+        const shouldAdjust = compareAddresses(path[Number(swapType)], weth);
+        if (!shouldAdjust) {
+            return { adjustedTokenAmount: tokenAmount, swapFee: 0n };
+        }
+        const swapFee = (tokenAmount * swapFeePercentage) / PERCENT_DENOMINATOR;
+        const adjustedTokenAmount = swapType === SwapType.EXACT_INPUT
+            ? tokenAmount - swapFee
+            : tokenAmount + swapFee;
+        return { adjustedTokenAmount, swapFee };
+    }
+    _adjustQuoteForSwapFeeAndSlippage(quote, swapFeePercentage, slippage, swapType, path) {
+        const weth = this.addresses.tokens.WETH;
+        const sign = swapType === SwapType.EXACT_INPUT ? -1n : 1n;
+        const slippageTolerance = calcSlippageTolerance(quote, slippage) * sign;
+        const quoteWithSlippage = quote + slippageTolerance;
+        const shouldAdjustQuote = !compareAddresses(path[Number(swapType)], weth);
+        if (!shouldAdjustQuote) {
+            return { adjustedQuote: quoteWithSlippage, swapFee: 0n };
+        }
+        const swapFee = (quote * swapFeePercentage) / PERCENT_DENOMINATOR;
+        const adjustedQuote = swapType === SwapType.EXACT_INPUT
+            ? quoteWithSlippage - swapFee
+            : quoteWithSlippage + swapFee;
+        return { adjustedQuote, swapFee };
+    }
+}