@paraswap/dex-lib 4.6.21 → 4.6.22

package/build/dex/ekubo/ekubo.js

@@ -51,12 +51,14 @@ const utils_3 = require("ethers/lib/utils");
 const router_json_1 = __importDefault(require("../../abi/ekubo/router.json"));
 const full_range_1 = require("./pools/full-range");
 const constants_2 = require("./pools/math/constants");
-const price_1 = require("./pools/math/price");
+const sqrt_ratio_1 = require("./pools/math/sqrt-ratio");
 const swap_1 = require("./pools/math/swap");
 const tick_1 = require("./pools/math/tick");
 const oracle_1 = require("./pools/oracle");
 const twamm_1 = require("./pools/twamm");
 const utils_4 = require("./pools/utils");
+const mev_resist_1 = require("./pools/mev-resist");
+const utils_5 = require("../../lib/tokens/utils");
 const FALLBACK_POOL_PARAMETERS = [
     {
         fee: 1844674407370955n,
@@ -79,15 +81,6 @@ const FALLBACK_POOL_PARAMETERS = [
         tickSpacing: 95310,
     },
 ];
-const tokenPairSchema = joi_1.default.object({
-    topPools: joi_1.default.array().items(joi_1.default.object({
-        fee: joi_1.default.string(),
-        tick_spacing: joi_1.default.number(),
-        extension: joi_1.default.string(),
-        tvl0_total: joi_1.default.string(),
-        tvl1_total: joi_1.default.string(),
-    })),
-});
 const allPoolsSchema = joi_1.default.array().items(joi_1.default.object({
     core_address: joi_1.default.string(),
     token0: joi_1.default.string(),
@@ -107,9 +100,9 @@ class Ekubo extends simple_exchange_1.SimpleExchange {
     hasConstantPriceLargeAmounts = false;
     needWrapNative = false;
     isFeeOnTransferSupported = false;
-    static dexKeysWithNetwork = (0, utils_1.getDexKeysWithNetwork)(config_1.EkuboConfig);
-    poolKeys = [];
+    static dexKeysWithNetwork = (0, utils_1.getDexKeysWithNetwork)(config_1.EKUBO_CONFIG);
     pools = new Map();
+    poolKeysSynced = false;
     logger;
     config;
     routerIface;
@@ -117,61 +110,146 @@ class Ekubo extends simple_exchange_1.SimpleExchange {
     supportedExtensions;
     interval;
     // Caches the number of decimals for TVL computation purposes
-    /*private readonly decimals: Record<string, number> = {
-      [ETHER_ADDRESS]: 18,
-    };*/
+    decimals = {
+        [constants_1.ETHER_ADDRESS]: 18,
+    };
     constructor(network, dexKey, dexHelper) {
         super(dexHelper, dexKey);
         this.network = network;
         this.dexKey = dexKey;
         this.dexHelper = dexHelper;
         this.logger = dexHelper.getLogger(dexKey);
-        this.config = config_1.EkuboConfig[dexKey][network];
+        this.config = config_1.EKUBO_CONFIG[dexKey][network];
         this.contracts = (0, utils_2.contractsFromDexParams)(this.config, dexHelper.provider);
         this.routerIface = new abi_1.Interface(router_json_1.default);
-        // 0 are vanilla pools
         this.supportedExtensions = [
-            0n,
+            0n, // Vanilla pools
             BigInt(this.config.oracle),
             BigInt(this.config.twamm),
+            BigInt(this.config.mevResist),
         ];
     }
-    // Periodically schedules fetching pool keys from the Ekubo API and filling in details with the quote data fetcher
     async initializePricing(blockNumber) {
-        await this.updatePoolMap(blockNumber);
-        this.interval = setInterval(async () => {
-            await this.updatePoolMap(await this.dexHelper.provider.getBlockNumber());
-        }, POOL_MAP_UPDATE_INTERVAL_MS);
-    }
-    // LEGACY
-    getAdapters(_side) {
-        return null;
+        await this.updatePools(blockNumber, true);
+        // Periodically schedules fetching pool keys from the Ekubo API and filling in details with the quote data fetcher
+        this.interval = setInterval(async () => this.updatePools(await this.dexHelper.provider.getBlockNumber(), true), POOL_MAP_UPDATE_INTERVAL_MS);
     }
-    async getPoolIdentifiers(srcToken, destToken, _side, _blockNumber) {
-        const [token0, token1] = (0, utils_2.convertAndSortTokens)(srcToken, destToken);
+    async updatePools(blockNumber, subscribe) {
         let poolKeys;
-        if (this.poolKeys === null) {
-            poolKeys = FALLBACK_POOL_PARAMETERS.flatMap(params => [
-                new utils_4.PoolKey(token0, token1, new utils_4.PoolConfig(params.tickSpacing, params.fee, 0n)),
-                new utils_4.PoolKey(token0, token1, new utils_4.PoolConfig(0, params.fee, BigInt(this.config.twamm))),
-            ]);
-            if ([token0, token1].includes(utils_2.NATIVE_TOKEN_ADDRESS)) {
-                poolKeys.push(new utils_4.PoolKey(token0, token1, new utils_4.PoolConfig(tick_1.FULL_RANGE_TICK_SPACING, 0n, BigInt(this.config.oracle))));
+        try {
+            [poolKeys, this.poolKeysSynced] = [await this.fetchAllPoolKeys(), true];
+        }
+        catch (err) {
+            this.logger.error(`Fetching pool keys from Ekubo API failed: ${err}`);
+            [poolKeys, this.poolKeysSynced] = [[], false];
+            if (subscribe) {
+                return;
             }
         }
-        else {
-            poolKeys = this.poolKeys.filter(poolKey => poolKey.token0 === token0 && poolKey.token1 === token1);
+        const untrackedPoolKeys = poolKeys.filter(poolKey => !this.pools.has(poolKey.stringId));
+        const [twammPoolKeys, otherPoolKeys] = untrackedPoolKeys.reduce(([twammPoolKeys, otherPoolKeys], poolKey) => {
+            if (poolKey.config.extension === BigInt(this.config.twamm)) {
+                twammPoolKeys.push(poolKey);
+            }
+            else {
+                otherPoolKeys.push(poolKey);
+            }
+            return [twammPoolKeys, otherPoolKeys];
+        }, [[], []]);
+        const promises = [];
+        if (!subscribe) {
+            promises.push(...this.pools.values().map(pool => pool.updateState(blockNumber).catch(err => {
+                this.logger.error(`Updating state of pool ${pool.key.stringId} failed: ${err}`);
+            })));
+        }
+        const commonArgs = [
+            this.dexKey,
+            this.dexHelper,
+            this.logger,
+            this.contracts,
+        ];
+        const addPool = async (constructor, initialState, poolKey) => {
+            const pool = new constructor(...commonArgs, poolKey);
+            if (subscribe) {
+                await pool.initialize(blockNumber, { state: initialState });
+            }
+            else {
+                pool.setState(initialState ?? (await pool.generateState(blockNumber)), blockNumber);
+            }
+            this.pools.set(poolKey.stringId, pool);
+        };
+        for (let batchStart = 0; batchStart < otherPoolKeys.length; batchStart += MAX_BATCH_SIZE) {
+            const batch = otherPoolKeys.slice(batchStart, batchStart + MAX_BATCH_SIZE);
+            promises.push(this.contracts.core.dataFetcher.getQuoteData(batch.map(poolKey => poolKey.toAbi()), MIN_TICK_SPACINGS_PER_POOL, {
+                blockTag: blockNumber,
+            })
+                .then(async (fetchedData) => {
+                await Promise.all(fetchedData.map(async (data, i) => {
+                    const poolKey = otherPoolKeys[batchStart + i];
+                    const extension = poolKey.config.extension;
+                    try {
+                        switch (extension) {
+                            case 0n: {
+                                if (poolKey.config.tickSpacing === 0) {
+                                    await addPool(full_range_1.FullRangePool, full_range_1.FullRangePoolState.fromQuoter(data), poolKey);
+                                }
+                                else {
+                                    await addPool(base_1.BasePool, base_1.BasePoolState.fromQuoter(data), poolKey);
+                                }
+                                break;
+                            }
+                            case BigInt(this.config.oracle): {
+                                await addPool(oracle_1.OraclePool, full_range_1.FullRangePoolState.fromQuoter(data), poolKey);
+                                break;
+                            }
+                            case BigInt(this.config.mevResist): {
+                                await addPool(mev_resist_1.MevResistPool, base_1.BasePoolState.fromQuoter(data), poolKey);
+                                break;
+                            }
+                            default:
+                                throw new Error(`Unknown pool extension ${(0, utils_3.hexZeroPad)((0, utils_3.hexlify)(extension), 20)}`);
+                        }
+                    }
+                    catch (err) {
+                        this.logger.error(`Failed to construct pool ${poolKey.stringId}: ${err}`);
+                    }
+                }));
+            })
+                .catch((err) => {
+                this.logger.error(`Fetching batch failed. Pool keys: ${batch.map(poolKey => poolKey.stringId)}. Error: ${err}`);
+            }));
         }
-        const ids = [];
-        for (const poolKey of poolKeys) {
-            if (this.pools.has(poolKey.string_id)) {
-                ids.push(poolKey.string_id);
+        promises.push(...twammPoolKeys.map(async (poolKey) => {
+            // The TWAMM data fetcher doesn't allow fetching state for multiple pools at once, so we just let `generateState` work to avoid duplicating logic
+            try {
+                await addPool(twamm_1.TwammPool, undefined, poolKey);
+            }
+            catch (err) {
+                this.logger.error(`Failed to construct pool ${poolKey.stringId}: ${err}`);
+            }
+        }));
+        await Promise.all(promises);
+    }
+    async getPoolIdentifiers(srcToken, destToken, _side, _blockNumber) {
+        const [token0, token1] = (0, utils_2.convertAndSortTokens)(srcToken, destToken);
+        const stringIds = new Set(this.pools
+            .entries()
+            .filter(([_, pool]) => pool.key.token0 === token0 && pool.key.token1 === token1)
+            .map(([stringId, _]) => stringId));
+        if (!this.poolKeysSynced) {
+            for (const params of FALLBACK_POOL_PARAMETERS) {
+                stringIds
+                    .add(new utils_4.PoolKey(token0, token1, new utils_4.PoolConfig(0n, params.fee, params.tickSpacing)).stringId)
+                    .add(new utils_4.PoolKey(token0, token1, new utils_4.PoolConfig(BigInt(this.config.twamm), params.fee, 0)).stringId);
+            }
+            if ([token0, token1].includes(utils_2.NATIVE_TOKEN_ADDRESS)) {
+                stringIds.add(new utils_4.PoolKey(token0, token1, new utils_4.PoolConfig(BigInt(this.config.oracle), 0n, tick_1.FULL_RANGE_TICK_SPACING)).stringId);
             }
         }
-        return ids;
+        return Array.from(stringIds);
     }
     async getPricesVolume(srcToken, destToken, amounts, side, blockNumber, limitPools) {
-        const pools = this.getInitializedPools(srcToken, destToken, limitPools);
+        const pools = await this.getPools(srcToken, destToken, blockNumber, limitPools);
         const isExactOut = side === constants_1.SwapSide.BUY;
         const amountToken = isExactOut ? destToken : srcToken;
         const amountTokenAddress = (0, utils_2.convertParaSwapToEkubo)(amountToken.address);
@@ -180,15 +258,15 @@ class Ekubo extends simple_exchange_1.SimpleExchange {
         const exchangePrices = [];
         // eslint-disable-next-line no-restricted-syntax
         poolLoop: for (const pool of pools) {
-            const poolId = pool.key.string_id;
+            const poolId = pool.key.stringId;
             try {
                 const quotes = [];
                 const skipAheadMap = {};
                 for (const amount of [unitAmount, ...amounts]) {
                     const inputAmount = isExactOut ? -amount : amount;
                     const quote = pool.quote(inputAmount, amountTokenAddress, blockNumber);
-                    if (isExactOut && quote.consumedAmount !== inputAmount) {
-                        this.logger.debug(`Pool ${poolId} doesn't have enough liquidity to support exact-out swap of ${amount} ${amountToken.symbol ?? amountToken.address}`);
+                    if (quote.consumedAmount !== inputAmount) {
+                        this.logger.debug(`Pool ${poolId} doesn't have enough liquidity to support swap of ${amount} ${amountToken.symbol ?? amountToken.address}`);
                         // There doesn't seem to be a way to skip just this one price.
                         // Anyway, this pool is probably not the right one if it has such thin liquidity.
                         continue poolLoop;
@@ -217,87 +295,6 @@ class Ekubo extends simple_exchange_1.SimpleExchange {
         }
         return exchangePrices;
     }
-    // LEGACY
-    getCalldataGasCost(_poolPrices) {
-        return CALLDATA_GAS_COST.DEX_NO_PAYLOAD;
-    }
-    // LEGACY
-    getAdapterParam(_srcToken, _destToken, _srcAmount, _destAmount, _data, _side) {
-        return {
-            targetExchange: this.dexKey,
-            payload: '',
-            networkFee: '0',
-        };
-    }
-    async updatePoolState() { }
-    async getTopPoolsForToken(tokenAddress, limit) {
-        return [];
-        // // The integration tests skip initializePricing, hence this check
-        // if (this.pools.size === 0) {
-        //   await this.updatePoolMap(await this.dexHelper.provider.getBlockNumber());
-        // }
-        // const token = convertParaSwapToEkubo(tokenAddress);
-        // const settledPromises = await Promise.allSettled(
-        //   Array.from(this.pools.entries()).map(async ([poolId, pool]) => {
-        //     const tokenPair = [pool.key.token0, pool.key.token1];
-        //     if (!tokenPair.includes(token)) {
-        //       return null;
-        //     }
-        //     const tvlRes = pool.computeTvl();
-        //     if (tvlRes === null) {
-        //       throw new Error(`failed to compute TVL for pool ${poolId}`);
-        //     }
-        //     const [info0, info1] = await Promise.all(
-        //       tokenPair.map((ekuboToken, i) =>
-        //         (async () => {
-        //           const paraswapToken = convertEkuboToParaSwap(ekuboToken);
-        //           const decimals = await this.getDecimals(paraswapToken);
-        //           const token = {
-        //             address: paraswapToken,
-        //             decimals,
-        //           };
-        //           return {
-        //             token,
-        //             tvl: await this.dexHelper.getTokenUSDPrice(token, tvlRes[i]),
-        //           };
-        //         })(),
-        //       ),
-        //     );
-        //     return {
-        //       exchange: this.dexKey,
-        //       address: this.config.core,
-        //       connectorTokens: [
-        //         (info0.token.address !== tokenAddress ? info0 : info1).token,
-        //       ],
-        //       liquidityUSD: info0.tvl + info1.tvl,
-        //     };
-        //   }),
-        // );
-        // const poolLiquidities = settledPromises.flatMap(res => {
-        //   if (res.status === 'rejected') {
-        //     this.logger.error('TVL computation failed:', res.reason);
-        //     return [];
-        //   }
-        //   return res.value ? [res.value] : [];
-        // });
-        // poolLiquidities
-        //   .sort((a, b) => b.liquidityUSD - a.liquidityUSD)
-        //   .splice(limit, Infinity);
-        // return poolLiquidities;
-    }
-    // private async getDecimals(paraswapToken: string): Promise<number> {
-    //   const cached = this.decimals[paraswapToken];
-    //   if (typeof cached === 'number') {
-    //     return cached;
-    //   }
-    //   const decimals: number = await new Contract(
-    //     paraswapToken,
-    //     erc20Iface,
-    //     this.dexHelper.provider,
-    //   ).decimals();
-    //   this.decimals[paraswapToken] = decimals;
-    //   return decimals;
-    // }
     getDexParam(_srcToken, _destToken, srcAmount, destAmount, recipient, data, side, _context, _executorAddress) {
         const amount = BigInt(side === constants_1.SwapSide.BUY ? `-${destAmount}` : srcAmount);
         const amountStr = (side === constants_1.SwapSide.SELL ? srcAmount : destAmount).toString();
@@ -308,8 +305,8 @@ class Ekubo extends simple_exchange_1.SimpleExchange {
                 data.isToken1,
                 ethers_1.BigNumber.from(amount),
                 (0, swap_1.isPriceIncreasing)(amount, data.isToken1)
-                    ? price_1.MAX_SQRT_RATIO_FLOAT
-                    : price_1.MIN_SQRT_RATIO_FLOAT,
+                    ? sqrt_ratio_1.MAX_SQRT_RATIO_FLOAT
+                    : sqrt_ratio_1.MIN_SQRT_RATIO_FLOAT,
                 ethers_1.BigNumber.from(data.skipAhead[amountStr] ?? 0),
                 constants_2.MIN_I256,
                 recipient,
@@ -319,115 +316,77 @@ class Ekubo extends simple_exchange_1.SimpleExchange {
             returnAmountPos: undefined,
         };
     }
-    releaseResources() {
-        if (this.interval) {
-            clearInterval(this.interval);
-            this.interval = undefined;
-        }
+    async updatePoolState() {
+        return this.updatePools(await this.dexHelper.provider.getBlockNumber(), false);
     }
-    getInitializedPools(tokenA, tokenB, limitPools) {
-        const [token0, token1] = (0, utils_2.convertAndSortTokens)(tokenA, tokenB);
-        const unfilteredPools = typeof limitPools === 'undefined'
-            ? Array.from(this.pools.values())
-            : limitPools.flatMap(poolId => {
-                const pool = this.pools.get(poolId);
-                if (typeof pool === 'undefined') {
-                    this.logger.warn(`Pool ${poolId} requested but not found`);
-                    return [];
+    async getTopPoolsForToken(tokenAddress, limit) {
+        const poolsTokenTvls = (await Promise.all(this.pools.values().map(async (pool) => {
+            try {
+                const tokenPair = [
+                    (0, utils_2.convertEkuboToParaSwap)(pool.key.token0),
+                    (0, utils_2.convertEkuboToParaSwap)(pool.key.token1),
+                ];
+                if (!tokenPair.includes(tokenAddress)) {
+                    return null;
                 }
-                return [pool];
-            });
-        return unfilteredPools.filter(pool => pool.key.token0 === token0 && pool.key.token1 === token1);
-    }
-    async updatePoolMap(blockNumber) {
-        try {
-            this.poolKeys = await this.fetchAllPoolKeys();
-        }
-        catch (err) {
-            this.logger.error(`Updating pool map from Ekubo API failed: ${err}`);
-            this.poolKeys = null;
-            return;
-        }
-        const uninitializedPoolKeys = this.poolKeys.filter(poolKey => !this.pools.has(poolKey.string_id));
-        const promises = this.initializePools(uninitializedPoolKeys, blockNumber);
-        (await Promise.allSettled(promises)).flatMap(res => {
-            if (res.status === 'rejected') {
-                this.logger.error(`Fetching batch failed. Pool keys: ${res.reason.batch}. Error: ${res.reason.err}`);
+                const tvls = pool.computeTvl();
+                const [token0Tvl, token1Tvl] = await Promise.all(tokenPair.map(async (tokenAddress, i) => {
+                    const decimals = await this.getDecimals(tokenAddress);
+                    if (decimals === null) {
+                        return null;
+                    }
+                    return {
+                        tvl: tvls[i],
+                        address: tokenAddress,
+                        decimals,
+                    };
+                }));
+                if (token0Tvl === null || token1Tvl === null) {
+                    return null;
+                }
+                return {
+                    pool,
+                    token0Tvl,
+                    token1Tvl,
+                };
             }
+            catch (err) {
+                this.logger.error(`TVL computation for pool ${pool.key.stringId} failed: ${err}`);
+                return null;
+            }
+        }))).filter(res => res !== null);
+        const usdTvls = await this.dexHelper.getUsdTokenAmounts(poolsTokenTvls.flatMap(({ token0Tvl, token1Tvl }) => [
+            [token0Tvl.address, token0Tvl.tvl],
+            [token1Tvl.address, token1Tvl.tvl],
+        ]));
+        const poolLiquidities = poolsTokenTvls.map(({ token0Tvl, token1Tvl }, i) => {
+            const [token0UsdTvl, token1UsdTvl] = usdTvls.slice(i * 2, i * 2 + 2);
+            const [connector, thisLiquidityUSD, connectorLiquidityUsd] = token0Tvl.address === tokenAddress
+                ? [token1Tvl, token0UsdTvl, token1UsdTvl]
+                : [token0Tvl, token1UsdTvl, token0UsdTvl];
+            return {
+                exchange: this.dexKey,
+                address: this.config.core,
+                connectorTokens: [
+                    {
+                        address: connector.address,
+                        decimals: connector.decimals,
+                        liquidityUSD: connectorLiquidityUsd,
+                    },
+                ],
+                liquidityUSD: thisLiquidityUSD,
+            };
         });
+        poolLiquidities
+            .sort((a, b) => b.liquidityUSD - a.liquidityUSD)
+            .splice(limit, Infinity);
+        return poolLiquidities;
     }
-    initializePools(poolKeys, blockNumber) {
-        const promises = [];
-        const [normalPoolKeys, twammPoolKeys] = poolKeys.reduce(([normalPoolKeys, twammPoolKeys], poolKey) => {
-            if (poolKey.config.extension == BigInt(this.config.twamm)) {
-                twammPoolKeys.push(poolKey);
-            }
-            else {
-                normalPoolKeys.push(poolKey);
-            }
-            return [normalPoolKeys, twammPoolKeys];
-        }, [[], []]);
-        const commonArgs = [
-            this.dexKey,
-            this.dexHelper,
-            this.logger,
-            this.contracts,
-        ];
-        function constructAndInitialize(constructor, initialState, poolKey) {
-            const pool = new constructor(...commonArgs, poolKey);
-            // This is fulfilled immediately
-            pool.initialize(blockNumber, { state: initialState });
-            return pool;
-        }
-        for (let batchStart = 0; batchStart < normalPoolKeys.length; batchStart += MAX_BATCH_SIZE) {
-            const batch = normalPoolKeys.slice(batchStart, batchStart + MAX_BATCH_SIZE);
-            promises.push((async () => {
-                const fetchedData = await this.contracts.core.dataFetcher.getQuoteData(batch.map(poolKey => poolKey.toAbi()), MIN_TICK_SPACINGS_PER_POOL, {
-                    blockTag: blockNumber,
-                });
-                return fetchedData.map((data, i) => {
-                    const poolKey = normalPoolKeys[batchStart + i];
-                    const extension = poolKey.config.extension;
-                    let pool;
-                    switch (extension) {
-                        case 0n: {
-                            if (poolKey.config.tickSpacing === 0) {
-                                pool = constructAndInitialize(full_range_1.FullRangePool, full_range_1.FullRangePoolState.fromQuoter(data), poolKey);
-                            }
-                            else {
-                                pool = constructAndInitialize(base_1.BasePool, base_1.BasePoolState.fromQuoter(data), poolKey);
-                            }
-                            break;
-                        }
-                        case BigInt(this.config.oracle): {
-                            pool = constructAndInitialize(oracle_1.OraclePool, full_range_1.FullRangePoolState.fromQuoter(data), poolKey);
-                            break;
-                        }
-                        default:
-                            throw new Error(`Unknown pool extension ${(0, utils_3.hexlify)(extension)}`);
-                    }
-                    return pool;
-                });
-            })().catch(err => {
-                throw {
-                    batch,
-                    err,
-                };
-            }));
+    releaseResources() {
+        if (this.interval) {
+            clearInterval(this.interval);
+            this.interval = undefined;
         }
-        promises.push(...twammPoolKeys.map(poolKey => (async () => {
-            const quoteData = await this.contracts.twamm.dataFetcher.getPoolState(poolKey.toAbi(), {
-                blockTag: blockNumber,
-            });
-            return [
-                constructAndInitialize(twamm_1.TwammPool, twamm_1.TwammPoolState.fromQuoter(quoteData), poolKey),
-            ];
-        })()));
-        return promises.map(promise => promise.then(pools => pools.map(pool => {
-            const poolId = pool.key.string_id;
-            this.pools.set(poolId, pool);
-            return poolId;
-        })));
     }
     async fetchAllPoolKeys() {
         const res = await this.dexHelper.httpRequest.get(`${this.config.apiUrl}/v1/poolKeys`);
@@ -442,7 +401,96 @@ class Ekubo extends simple_exchange_1.SimpleExchange {
             .filter(res => this.supportedExtensions.includes(BigInt(res.extension)) &&
             BigInt(res.core_address) ===
                 BigInt(this.contracts.core.contract.address))
-            .map(info => new utils_4.PoolKey(BigInt(info.token0), BigInt(info.token1), new utils_4.PoolConfig(info.tick_spacing, BigInt(info.fee), BigInt(info.extension))));
+            .map(info => new utils_4.PoolKey(BigInt(info.token0), BigInt(info.token1), new utils_4.PoolConfig(BigInt(info.extension), BigInt(info.fee), info.tick_spacing)));
+    }
+    getDecimals(erc20Token) {
+        const cached = this.decimals[erc20Token];
+        if (typeof cached !== 'undefined') {
+            return cached;
+        }
+        const call = new ethers_1.Contract(erc20Token, utils_5.erc20Iface, this.dexHelper.provider).decimals();
+        const promise = call.catch((err) => {
+            this.logger.error('Failed to fetch decimals for token', erc20Token, 'due to:', err);
+            return null;
+        });
+        this.decimals[erc20Token] = promise;
+        return promise;
+    }
+    async getPools(tokenA, tokenB, blockNumber, limitPools) {
+        const [token0, token1] = (0, utils_2.convertAndSortTokens)(tokenA, tokenB);
+        let unfilteredPools;
+        if (typeof limitPools === 'undefined') {
+            unfilteredPools = this.pools.values();
+        }
+        else {
+            const unfilteredPoolsArr = [];
+            await Promise.all(limitPools.map(async (stringId) => {
+                let pool = this.pools.get(stringId);
+                if (typeof pool === 'undefined') {
+                    try {
+                        pool = await this.initializeUntrackedPool(stringId, blockNumber);
+                    }
+                    catch (err) {
+                        this.logger.error(`Initializing pool ${stringId} failed: ${err}`);
+                        return;
+                    }
+                }
+                unfilteredPoolsArr.push(pool);
+            }));
+            unfilteredPools = Iterator.from(unfilteredPoolsArr);
+        }
+        return unfilteredPools.filter(pool => pool.key.token0 === token0 && pool.key.token1 === token1);
+    }
+    async initializeUntrackedPool(stringId, blockNumber) {
+        const poolKey = utils_4.PoolKey.fromStringId(stringId);
+        let constructor;
+        const extension = poolKey.config.extension;
+        switch (extension) {
+            case 0n: {
+                if (poolKey.config.tickSpacing === 0) {
+                    constructor = full_range_1.FullRangePool;
+                }
+                else {
+                    constructor = base_1.BasePool;
+                }
+                break;
+            }
+            case BigInt(this.config.oracle): {
+                constructor = oracle_1.OraclePool;
+                break;
+            }
+            case BigInt(this.config.twamm): {
+                constructor = twamm_1.TwammPool;
+                break;
+            }
+            case BigInt(this.config.mevResist): {
+                constructor = mev_resist_1.MevResistPool;
+                break;
+            }
+            default: {
+                throw new Error(`Unknown pool extension ${(0, utils_3.hexZeroPad)((0, utils_3.hexlify)(extension), 20)}`);
+            }
+        }
+        const pool = new constructor(this.dexKey, this.dexHelper, this.logger, this.contracts, poolKey);
+        await pool.initialize(blockNumber);
+        this.pools.set(stringId, pool);
+        return pool;
+    }
+    // LEGACY
+    getAdapters(_side) {
+        return null;
+    }
+    // LEGACY
+    getCalldataGasCost(_poolPrices) {
+        return CALLDATA_GAS_COST.DEX_NO_PAYLOAD;
+    }
+    // LEGACY
+    getAdapterParam(_srcToken, _destToken, _srcAmount, _destAmount, _data, _side) {
+        return {
+            targetExchange: this.dexKey,
+            payload: '',
+            networkFee: '0',
+        };
     }
 }
 exports.Ekubo = Ekubo;