@fanx-protocol/smart-order-router 0.0.1

package/build/module/providers/caching-subgraph-provider.js

@@ -0,0 +1,33 @@
+import { ChainId } from '@fanx-protocol/sdk-core';
+import { WRAPPED_NATIVE_CURRENCY } from '../util';
+import { USDC_CHILIZ, USDC_SPICY } from './token-provider';
+export const BASES_TO_CHECK_TRADES_AGAINST = {
+    [ChainId.SPICY]: [WRAPPED_NATIVE_CURRENCY[ChainId.SPICY], USDC_SPICY],
+    [ChainId.CHILIZ]: [WRAPPED_NATIVE_CURRENCY[ChainId.CHILIZ], USDC_CHILIZ],
+};
+export class CachingSubgraphProvider {
+    /**
+     * Creates an instance of CachingV3SubgraphProvider.
+     * @param chainId The chain id to use.
+     * @param subgraphProvider The provider to use to get the subgraph pools when not in the cache.
+     * @param cache Cache instance to hold cached pools.
+     * @param protocol Subgraph protocol version
+     */
+    constructor(chainId, subgraphProvider, cache, protocol) {
+        this.chainId = chainId;
+        this.subgraphProvider = subgraphProvider;
+        this.cache = cache;
+        this.protocol = protocol;
+        this.SUBGRAPH_KEY = (chainId) => `subgraph-pools-${this.protocol}-${chainId}`;
+    }
+    async getPools() {
+        const cachedPools = await this.cache.get(this.SUBGRAPH_KEY(this.chainId));
+        if (cachedPools) {
+            return cachedPools;
+        }
+        const pools = await this.subgraphProvider.getPools();
+        await this.cache.set(this.SUBGRAPH_KEY(this.chainId), pools);
+        return pools;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FjaGluZy1zdWJncmFwaC1wcm92aWRlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9wcm92aWRlcnMvY2FjaGluZy1zdWJncmFwaC1wcm92aWRlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsT0FBTyxFQUFTLE1BQU0seUJBQXlCLENBQUM7QUFHekQsT0FBTyxFQUFFLHVCQUF1QixFQUFFLE1BQU0sU0FBUyxDQUFDO0FBSWxELE9BQU8sRUFBRSxXQUFXLEVBQUUsVUFBVSxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFPM0QsTUFBTSxDQUFDLE1BQU0sNkJBQTZCLEdBQW1CO0lBQzNELENBQUMsT0FBTyxDQUFDLEtBQUssQ0FBQyxFQUFFLENBQUMsdUJBQXVCLENBQUMsT0FBTyxDQUFDLEtBQUssQ0FBRSxFQUFFLFVBQVUsQ0FBQztJQUN0RSxDQUFDLE9BQU8sQ0FBQyxNQUFNLENBQUMsRUFBRSxDQUFDLHVCQUF1QixDQUFDLE9BQU8sQ0FBQyxNQUFNLENBQUUsRUFBRSxXQUFXLENBQUM7Q0FDMUUsQ0FBQztBQWtCRixNQUFNLE9BQWdCLHVCQUF1QjtJQU8zQzs7Ozs7O09BTUc7SUFDSCxZQUNVLE9BQWdCLEVBQ2QsZ0JBQWtELEVBQ3BELEtBQThCLEVBQzlCLFFBQWtCO1FBSGxCLFlBQU8sR0FBUCxPQUFPLENBQVM7UUFDZCxxQkFBZ0IsR0FBaEIsZ0JBQWdCLENBQWtDO1FBQ3BELFVBQUssR0FBTCxLQUFLLENBQXlCO1FBQzlCLGFBQVEsR0FBUixRQUFRLENBQVU7UUFkcEIsaUJBQVksR0FBRyxDQUFDLE9BQWdCLEVBQUUsRUFBRSxDQUMxQyxrQkFBa0IsSUFBSSxDQUFDLFFBQVEsSUFBSSxPQUFPLEVBQUUsQ0FBQztJQWM1QyxDQUFDO0lBRUcsS0FBSyxDQUFDLFFBQVE7UUFDbkIsTUFBTSxXQUFXLEdBQUcsTUFBTSxJQUFJLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsWUFBWSxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDO1FBRTFFLElBQUksV0FBVyxFQUFFO1lBQ2YsT0FBTyxXQUFXLENBQUM7U0FDcEI7UUFFRCxNQUFNLEtBQUssR0FBRyxNQUFNLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyxRQUFRLEVBQUUsQ0FBQztRQUVyRCxNQUFNLElBQUksQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxZQUFZLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxFQUFFLEtBQUssQ0FBQyxDQUFDO1FBRTdELE9BQU8sS0FBSyxDQUFDO0lBQ2YsQ0FBQztDQUNGIn0=

package/build/module/providers/caching-token-list-provider.d.ts

@@ -0,0 +1,52 @@
+import { ChainId, Token } from '@fanx-protocol/sdk-core';
+import { TokenList } from '@uniswap/token-lists';
+import { ICache } from './cache';
+import { ITokenProvider, TokenAccessor } from './token-provider';
+/**
+ * Provider for getting token data from a Token List.
+ *
+ * @export
+ * @interface ITokenListProvider
+ */
+export interface ITokenListProvider {
+    hasTokenBySymbol(_symbol: string): Promise<boolean>;
+    getTokenBySymbol(_symbol: string): Promise<Token | undefined>;
+    hasTokenByAddress(address: string): Promise<boolean>;
+    getTokenByAddress(address: string): Promise<Token | undefined>;
+}
+export declare class CachingTokenListProvider implements ITokenProvider, ITokenListProvider {
+    private tokenCache;
+    private CACHE_KEY;
+    private chainId;
+    private chainToTokenInfos;
+    private chainSymbolToTokenInfo;
+    private chainAddressToTokenInfo;
+    private tokenList;
+    private CHAIN_SYMBOL_KEY;
+    private CHAIN_ADDRESS_KEY;
+    /**
+     * Creates an instance of CachingTokenListProvider.
+     * Token metadata (e.g. symbol and decimals) generally don't change so can be cached indefinitely.
+     *
+     * @param chainId The chain id to use.
+     * @param tokenList The token list to get the tokens from.
+     * @param tokenCache Cache instance to hold cached tokens.
+     */
+    constructor(chainId: ChainId | number, tokenList: TokenList, tokenCache: ICache<Token>);
+    static fromTokenListURI(chainId: ChainId | number, tokenListURI: string, tokenCache: ICache<Token>): Promise<CachingTokenListProvider>;
+    private static buildTokenList;
+    static fromTokenList(chainId: ChainId | number, tokenList: TokenList, tokenCache: ICache<Token>): Promise<CachingTokenListProvider>;
+    /**
+     * If no addresses array is specified, all tokens in the token list are
+     * returned.
+     *
+     * @param _addresses (optional) The token addresses to get.
+     * @returns Promise<TokenAccessor> A token accessor with methods for accessing the tokens.
+     */
+    getTokens(_addresses?: string[]): Promise<TokenAccessor>;
+    hasTokenBySymbol(_symbol: string): Promise<boolean>;
+    getTokenBySymbol(_symbol: string): Promise<Token | undefined>;
+    hasTokenByAddress(address: string): Promise<boolean>;
+    getTokenByAddress(address: string): Promise<Token | undefined>;
+    private buildToken;
+}

package/build/module/providers/caching-token-list-provider.js

@@ -0,0 +1,140 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+import { Token } from '@fanx-protocol/sdk-core';
+import axios from 'axios';
+import { log } from '../util/log';
+import { metric, MetricLoggerUnit } from '../util/metric';
+export class CachingTokenListProvider {
+    /**
+     * Creates an instance of CachingTokenListProvider.
+     * Token metadata (e.g. symbol and decimals) generally don't change so can be cached indefinitely.
+     *
+     * @param chainId The chain id to use.
+     * @param tokenList The token list to get the tokens from.
+     * @param tokenCache Cache instance to hold cached tokens.
+     */
+    constructor(chainId, tokenList, tokenCache) {
+        this.tokenCache = tokenCache;
+        this.CACHE_KEY = (tokenInfo) => `token-list-token-${this.chainId}/${this.tokenList.name}/${this.tokenList.timestamp}/${this.tokenList.version}/${tokenInfo.address.toLowerCase()}/${tokenInfo.decimals}/${tokenInfo.symbol}/${tokenInfo.name}`;
+        this.CHAIN_SYMBOL_KEY = (chainId, symbol) => `${chainId.toString()}/${symbol}`;
+        this.CHAIN_ADDRESS_KEY = (chainId, address) => `${chainId.toString()}/${address.toLowerCase()}`;
+        this.chainId = chainId;
+        this.tokenList = tokenList;
+        this.chainToTokenInfos = new Map();
+        this.chainSymbolToTokenInfo = new Map();
+        this.chainAddressToTokenInfo = new Map();
+        for (const tokenInfo of this.tokenList.tokens) {
+            const chainId = tokenInfo.chainId;
+            const chainIdString = chainId.toString();
+            const symbol = tokenInfo.symbol;
+            const address = tokenInfo.address.toLowerCase();
+            if (!this.chainToTokenInfos.has(chainIdString)) {
+                this.chainToTokenInfos.set(chainIdString, []);
+            }
+            this.chainToTokenInfos.get(chainIdString).push(tokenInfo);
+            this.chainSymbolToTokenInfo.set(this.CHAIN_SYMBOL_KEY(chainId, symbol), tokenInfo);
+            this.chainAddressToTokenInfo.set(this.CHAIN_ADDRESS_KEY(chainId, address), tokenInfo);
+        }
+    }
+    static async fromTokenListURI(chainId, tokenListURI, tokenCache) {
+        const now = Date.now();
+        const tokenList = await this.buildTokenList(tokenListURI);
+        metric.putMetric('TokenListLoad', Date.now() - now, MetricLoggerUnit.Milliseconds);
+        return new CachingTokenListProvider(chainId, tokenList, tokenCache);
+    }
+    static async buildTokenList(tokenListURI) {
+        log.info(`Getting tokenList from ${tokenListURI}.`);
+        const response = await axios.get(tokenListURI);
+        log.info(`Got tokenList from ${tokenListURI}.`);
+        const { data: tokenList, status } = response;
+        if (status != 200) {
+            log.error({ response }, `Unabled to get token list from ${tokenListURI}.`);
+            throw new Error(`Unable to get token list from ${tokenListURI}`);
+        }
+        return tokenList;
+    }
+    static async fromTokenList(chainId, tokenList, tokenCache) {
+        const now = Date.now();
+        const tokenProvider = new CachingTokenListProvider(chainId, tokenList, tokenCache);
+        metric.putMetric('TokenListLoad', Date.now() - now, MetricLoggerUnit.Milliseconds);
+        return tokenProvider;
+    }
+    /**
+     * If no addresses array is specified, all tokens in the token list are
+     * returned.
+     *
+     * @param _addresses (optional) The token addresses to get.
+     * @returns Promise<TokenAccessor> A token accessor with methods for accessing the tokens.
+     */
+    async getTokens(_addresses) {
+        var _a;
+        const addressToToken = new Map();
+        const symbolToToken = new Map();
+        const addToken = (token) => {
+            if (!token)
+                return;
+            addressToToken.set(token.address.toLowerCase(), token);
+            if (token.symbol !== undefined) {
+                symbolToToken.set(token.symbol.toLowerCase(), token);
+            }
+        };
+        if (_addresses) {
+            for (const address of _addresses) {
+                const token = await this.getTokenByAddress(address);
+                addToken(token);
+            }
+        }
+        else {
+            const chainTokens = (_a = this.chainToTokenInfos.get(this.chainId.toString())) !== null && _a !== void 0 ? _a : [];
+            for (const info of chainTokens) {
+                const token = await this.buildToken(info);
+                addToken(token);
+            }
+        }
+        return {
+            getTokenByAddress: (address) => addressToToken.get(address.toLowerCase()),
+            getTokenBySymbol: (symbol) => symbolToToken.get(symbol.toLowerCase()),
+            getAllTokens: () => {
+                return Array.from(addressToToken.values());
+            },
+        };
+    }
+    async hasTokenBySymbol(_symbol) {
+        return this.chainSymbolToTokenInfo.has(this.CHAIN_SYMBOL_KEY(this.chainId, _symbol));
+    }
+    async getTokenBySymbol(_symbol) {
+        let symbol = _symbol;
+        // We consider ETH as a regular ERC20 Token throughout this package. We don't use the NativeCurrency object from the sdk.
+        // When we build the calldata for swapping we insert wrapping/unwrapping as needed.
+        if (_symbol == 'ETH') {
+            symbol = 'WETH';
+        }
+        const tokenInfo = this.chainSymbolToTokenInfo.get(this.CHAIN_SYMBOL_KEY(this.chainId, symbol));
+        if (!tokenInfo) {
+            return undefined;
+        }
+        const token = await this.buildToken(tokenInfo);
+        return token;
+    }
+    async hasTokenByAddress(address) {
+        return this.chainAddressToTokenInfo.has(this.CHAIN_ADDRESS_KEY(this.chainId, address));
+    }
+    async getTokenByAddress(address) {
+        const tokenInfo = this.chainAddressToTokenInfo.get(this.CHAIN_ADDRESS_KEY(this.chainId, address));
+        if (!tokenInfo) {
+            return undefined;
+        }
+        const token = await this.buildToken(tokenInfo);
+        return token;
+    }
+    async buildToken(tokenInfo) {
+        const cacheKey = this.CACHE_KEY(tokenInfo);
+        const cachedToken = await this.tokenCache.get(cacheKey);
+        if (cachedToken) {
+            return cachedToken;
+        }
+        const token = new Token(this.chainId, tokenInfo.address, tokenInfo.decimals, tokenInfo.symbol, tokenInfo.name);
+        await this.tokenCache.set(cacheKey, token);
+        return token;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/module/providers/caching-token-provider.d.ts

@@ -0,0 +1,24 @@
+import { ChainId, Token } from '@fanx-protocol/sdk-core';
+import { ICache } from './cache';
+import { ITokenProvider, TokenAccessor } from './token-provider';
+export declare const CACHE_SEED_TOKENS: {
+    [chainId in ChainId]?: {
+        [symbol: string]: Token;
+    };
+};
+/**
+ * Provider for getting token metadata that falls back to a different provider
+ * in the event of failure.
+ *
+ * @export
+ * @class CachingTokenProviderWithFallback
+ */
+export declare class CachingTokenProviderWithFallback implements ITokenProvider {
+    protected chainId: ChainId;
+    private tokenCache;
+    protected primaryTokenProvider: ITokenProvider;
+    protected fallbackTokenProvider?: ITokenProvider | undefined;
+    private CACHE_KEY;
+    constructor(chainId: ChainId, tokenCache: ICache<Token>, primaryTokenProvider: ITokenProvider, fallbackTokenProvider?: ITokenProvider | undefined);
+    getTokens(_addresses: string[]): Promise<TokenAccessor>;
+}

package/build/module/providers/caching-token-provider.js

@@ -0,0 +1,101 @@
+import { ChainId } from '@fanx-protocol/sdk-core';
+import _ from 'lodash';
+import { log, WRAPPED_NATIVE_CURRENCY } from '../util';
+// These tokens will added to the Token cache on initialization.
+export const CACHE_SEED_TOKENS = {
+    [ChainId.CHILIZ]: {
+        WETH: WRAPPED_NATIVE_CURRENCY[ChainId.CHILIZ],
+    },
+    [ChainId.SPICY]: {
+        WETH: WRAPPED_NATIVE_CURRENCY[ChainId.SPICY],
+    },
+};
+/**
+ * Provider for getting token metadata that falls back to a different provider
+ * in the event of failure.
+ *
+ * @export
+ * @class CachingTokenProviderWithFallback
+ */
+export class CachingTokenProviderWithFallback {
+    constructor(chainId, 
+    // Token metadata (e.g. symbol and decimals) don't change so can be cached indefinitely.
+    // Constructing a new token object is slow as sdk-core does checksumming.
+    tokenCache, primaryTokenProvider, fallbackTokenProvider) {
+        this.chainId = chainId;
+        this.tokenCache = tokenCache;
+        this.primaryTokenProvider = primaryTokenProvider;
+        this.fallbackTokenProvider = fallbackTokenProvider;
+        this.CACHE_KEY = (chainId, address) => `token-${chainId}-${address}`;
+    }
+    async getTokens(_addresses) {
+        const seedTokens = CACHE_SEED_TOKENS[this.chainId];
+        if (seedTokens) {
+            for (const token of Object.values(seedTokens)) {
+                await this.tokenCache.set(this.CACHE_KEY(this.chainId, token.address.toLowerCase()), token);
+            }
+        }
+        const addressToToken = {};
+        const symbolToToken = {};
+        const addresses = _(_addresses)
+            .map((address) => address.toLowerCase())
+            .uniq()
+            .value();
+        const addressesToFindInPrimary = [];
+        const addressesToFindInSecondary = [];
+        for (const address of addresses) {
+            if (await this.tokenCache.has(this.CACHE_KEY(this.chainId, address))) {
+                addressToToken[address.toLowerCase()] = (await this.tokenCache.get(this.CACHE_KEY(this.chainId, address)));
+                symbolToToken[addressToToken[address].symbol] =
+                    (await this.tokenCache.get(this.CACHE_KEY(this.chainId, address)));
+            }
+            else {
+                addressesToFindInPrimary.push(address);
+            }
+        }
+        log.info({ addressesToFindInPrimary }, `Found ${addresses.length - addressesToFindInPrimary.length} out of ${addresses.length} tokens in local cache. ${addressesToFindInPrimary.length > 0
+            ? `Checking primary token provider for ${addressesToFindInPrimary.length} tokens`
+            : ``}
+      `);
+        if (addressesToFindInPrimary.length > 0) {
+            const primaryTokenAccessor = await this.primaryTokenProvider.getTokens(addressesToFindInPrimary);
+            for (const address of addressesToFindInPrimary) {
+                const token = primaryTokenAccessor.getTokenByAddress(address);
+                if (token) {
+                    addressToToken[address.toLowerCase()] = token;
+                    symbolToToken[addressToToken[address].symbol] = token;
+                    await this.tokenCache.set(this.CACHE_KEY(this.chainId, address.toLowerCase()), addressToToken[address]);
+                }
+                else {
+                    addressesToFindInSecondary.push(address);
+                }
+            }
+            log.info({ addressesToFindInSecondary }, `Found ${addressesToFindInPrimary.length - addressesToFindInSecondary.length} tokens in primary. ${this.fallbackTokenProvider
+                ? `Checking secondary token provider for ${addressesToFindInSecondary.length} tokens`
+                : `No fallback token provider specified. About to return.`}`);
+        }
+        if (this.fallbackTokenProvider && addressesToFindInSecondary.length > 0) {
+            const secondaryTokenAccessor = await this.fallbackTokenProvider.getTokens(addressesToFindInSecondary);
+            for (const address of addressesToFindInSecondary) {
+                const token = secondaryTokenAccessor.getTokenByAddress(address);
+                if (token) {
+                    addressToToken[address.toLowerCase()] = token;
+                    symbolToToken[addressToToken[address].symbol] = token;
+                    await this.tokenCache.set(this.CACHE_KEY(this.chainId, address.toLowerCase()), addressToToken[address]);
+                }
+            }
+        }
+        return {
+            getTokenByAddress: (address) => {
+                return addressToToken[address.toLowerCase()];
+            },
+            getTokenBySymbol: (symbol) => {
+                return symbolToToken[symbol.toLowerCase()];
+            },
+            getAllTokens: () => {
+                return Object.values(addressToToken);
+            },
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/module/providers/eip-1559-gas-price-provider.d.ts

@@ -0,0 +1,31 @@
+import { BigNumber } from '@ethersproject/bignumber';
+import { JsonRpcProvider } from '@ethersproject/providers';
+import { GasPrice, IGasPriceProvider } from './gas-price-provider';
+export declare type RawFeeHistoryResponse = {
+    baseFeePerGas: string[];
+    gasUsedRatio: number[];
+    oldestBlock: string;
+    reward: string[];
+};
+export declare type FeeHistoryResponse = {
+    baseFeePerGas: BigNumber[];
+    gasUsedRatio: number[];
+    oldestBlock: BigNumber;
+    reward: BigNumber[];
+};
+/**
+ * Computes a gas estimate using on-chain data from the eth_feeHistory RPC endpoint.
+ *
+ * Takes the average priority fee from the past `blocksToConsider` blocks, and adds it
+ * to the current base fee.
+ *
+ * @export
+ * @class EIP1559GasPriceProvider
+ */
+export declare class EIP1559GasPriceProvider extends IGasPriceProvider {
+    protected provider: JsonRpcProvider;
+    private priorityFeePercentile;
+    private blocksToConsider;
+    constructor(provider: JsonRpcProvider, priorityFeePercentile?: number, blocksToConsider?: number);
+    getGasPrice(_latestBlockNumber: number, requestBlockNumber?: number): Promise<GasPrice>;
+}

package/build/module/providers/eip-1559-gas-price-provider.js

@@ -0,0 +1,64 @@
+import { BigNumber } from '@ethersproject/bignumber';
+import _ from 'lodash';
+import { log } from '../util/log';
+import { IGasPriceProvider } from './gas-price-provider';
+// We get the Xth percentile of priority fees for transactions successfully included in previous blocks.
+const DEFAULT_PRIORITY_FEE_PERCENTILE = 50;
+// Infura docs say only past 4 blocks guaranteed to be available: https://infura.io/docs/ethereum#operation/eth_feeHistory
+const DEFAULT_BLOCKS_TO_LOOK_BACK = 4;
+/**
+ * Computes a gas estimate using on-chain data from the eth_feeHistory RPC endpoint.
+ *
+ * Takes the average priority fee from the past `blocksToConsider` blocks, and adds it
+ * to the current base fee.
+ *
+ * @export
+ * @class EIP1559GasPriceProvider
+ */
+export class EIP1559GasPriceProvider extends IGasPriceProvider {
+    constructor(provider, priorityFeePercentile = DEFAULT_PRIORITY_FEE_PERCENTILE, blocksToConsider = DEFAULT_BLOCKS_TO_LOOK_BACK) {
+        super();
+        this.provider = provider;
+        this.priorityFeePercentile = priorityFeePercentile;
+        this.blocksToConsider = blocksToConsider;
+    }
+    async getGasPrice(_latestBlockNumber, requestBlockNumber) {
+        const feeHistoryRaw = (await this.provider.send('eth_feeHistory', [
+            /**
+             * @fix Use BigNumber.from(this.blocksToConsider).toHexString() after hardhat adds support
+             * @see https://github.com/NomicFoundation/hardhat/issues/1585 .___.
+             */
+            BigNumber.from(this.blocksToConsider).toHexString().replace('0x0', '0x'),
+            // If the block number is not specified, we have to send hardcoded 'latest' to infura RPC
+            // because Infura node pool is eventually consistent and may not have the latest block from our block number.
+            // See https://uniswapteam.slack.com/archives/C023A7JDTJP/p1702485038251449?thread_ts=1702471203.519869&cid=C023A7JDTJP
+            requestBlockNumber
+                ? BigNumber.from(requestBlockNumber).toHexString().replace('0x0', '0x')
+                : 'latest',
+            [this.priorityFeePercentile],
+        ]));
+        const feeHistory = {
+            baseFeePerGas: _.map(feeHistoryRaw.baseFeePerGas, (b) => BigNumber.from(b)),
+            gasUsedRatio: feeHistoryRaw.gasUsedRatio,
+            oldestBlock: BigNumber.from(feeHistoryRaw.oldestBlock),
+            reward: _.map(feeHistoryRaw.reward, (b) => BigNumber.from(b[0])),
+        };
+        const nextBlockBaseFeePerGas = feeHistory.baseFeePerGas[feeHistory.baseFeePerGas.length - 1];
+        const averagePriorityFeePerGas = _.reduce(feeHistory.reward, (sum, cur) => sum.add(cur), BigNumber.from(0)).div(feeHistory.reward.length);
+        log.info({
+            feeHistory,
+            feeHistoryReadable: {
+                baseFeePerGas: _.map(feeHistory.baseFeePerGas, (f) => f.toString()),
+                oldestBlock: feeHistory.oldestBlock.toString(),
+                reward: _.map(feeHistory.reward, (r) => r.toString()),
+            },
+            nextBlockBaseFeePerGas: nextBlockBaseFeePerGas.toString(),
+            averagePriorityFeePerGas: averagePriorityFeePerGas.toString(),
+        }, 'Got fee history from provider and computed gas estimate');
+        const gasPriceWei = nextBlockBaseFeePerGas.add(averagePriorityFeePerGas);
+        const blockNumber = feeHistory.oldestBlock.add(this.blocksToConsider);
+        log.info(`Estimated gas price in wei: ${gasPriceWei} as of block ${blockNumber.toString()}`);
+        return { gasPriceWei: gasPriceWei };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/module/providers/eth-estimate-gas-provider.d.ts

@@ -0,0 +1,19 @@
+import { JsonRpcProvider } from '@ethersproject/providers';
+import { ChainId } from '@fanx-protocol/sdk-core';
+import { GasModelProviderConfig, SwapOptions, SwapRoute } from '../routers';
+import { IPortionProvider } from './portion-provider';
+import { ProviderConfig } from './provider';
+import { Simulator } from './simulation-provider';
+import { IV2PoolProvider } from './v2/pool-provider';
+import { IV3PoolProvider } from './v3/pool-provider';
+export declare class EthEstimateGasSimulator extends Simulator {
+    v2PoolProvider: IV2PoolProvider;
+    v3PoolProvider: IV3PoolProvider;
+    private overrideEstimateMultiplier;
+    constructor(chainId: ChainId, provider: JsonRpcProvider, v2PoolProvider: IV2PoolProvider, v3PoolProvider: IV3PoolProvider, portionProvider: IPortionProvider, overrideEstimateMultiplier?: {
+        [chainId in ChainId]?: number;
+    });
+    ethEstimateGas(fromAddress: string, swapOptions: SwapOptions, route: SwapRoute, providerConfig?: ProviderConfig): Promise<SwapRoute>;
+    private adjustGasEstimate;
+    protected simulateTransaction(fromAddress: string, swapOptions: SwapOptions, swapRoute: SwapRoute, _providerConfig?: GasModelProviderConfig): Promise<SwapRoute>;
+}

package/build/module/providers/eth-estimate-gas-provider.js

@@ -0,0 +1,102 @@
+import { BigNumber } from '@ethersproject/bignumber';
+import { SwapType, } from '../routers';
+import { log } from '../util';
+import { calculateGasUsed, initSwapRouteFromExisting, } from '../util/gas-factory-helpers';
+import { SimulationStatus, Simulator } from './simulation-provider';
+// import { IV4PoolProvider } from './v4/pool-provider';
+// We multiply eth estimate gas by this to add a buffer for gas limits
+const DEFAULT_ESTIMATE_MULTIPLIER = 1.2;
+export class EthEstimateGasSimulator extends Simulator {
+    constructor(chainId, provider, v2PoolProvider, v3PoolProvider, 
+    // v4PoolProvider: IV4PoolProvider,
+    portionProvider, overrideEstimateMultiplier) {
+        super(provider, portionProvider, chainId);
+        this.v2PoolProvider = v2PoolProvider;
+        this.v3PoolProvider = v3PoolProvider;
+        // this.v4PoolProvider = v4PoolProvider;
+        this.overrideEstimateMultiplier = overrideEstimateMultiplier !== null && overrideEstimateMultiplier !== void 0 ? overrideEstimateMultiplier : {};
+    }
+    async ethEstimateGas(fromAddress, swapOptions, route, providerConfig) {
+        const currencyIn = route.trade.inputAmount.currency;
+        let estimatedGasUsed;
+        if (swapOptions.type == SwapType.UNIVERSAL_ROUTER) {
+            // if (currencyIn.isNative && this.chainId == ChainId.MAINNET) {
+            //   // w/o this gas estimate differs by a lot depending on if user holds enough native balance
+            //   // always estimate gas as if user holds enough balance
+            //   // so that gas estimate is consistent for UniswapX
+            //   fromAddress = BEACON_CHAIN_DEPOSIT_ADDRESS;
+            // }
+            log.info({ addr: fromAddress, methodParameters: route.methodParameters }, 'Simulating using eth_estimateGas on Universal Router');
+            try {
+                estimatedGasUsed = await this.provider.estimateGas({
+                    data: route.methodParameters.calldata,
+                    to: route.methodParameters.to,
+                    from: fromAddress,
+                    value: BigNumber.from(currencyIn.isNative ? route.methodParameters.value : '0'),
+                });
+            }
+            catch (e) {
+                log.error({ e }, 'Error estimating gas');
+                return {
+                    ...route,
+                    simulationStatus: SimulationStatus.Failed,
+                };
+            }
+        }
+        else if (swapOptions.type == SwapType.SWAP_ROUTER_02) {
+            try {
+                estimatedGasUsed = await this.provider.estimateGas({
+                    data: route.methodParameters.calldata,
+                    to: route.methodParameters.to,
+                    from: fromAddress,
+                    value: BigNumber.from(currencyIn.isNative ? route.methodParameters.value : '0'),
+                });
+            }
+            catch (e) {
+                log.error({ e }, 'Error estimating gas');
+                return {
+                    ...route,
+                    simulationStatus: SimulationStatus.Failed,
+                };
+            }
+        }
+        else {
+            throw new Error(`Unsupported swap type ${swapOptions}`);
+        }
+        estimatedGasUsed = this.adjustGasEstimate(estimatedGasUsed);
+        log.info({
+            methodParameters: route.methodParameters,
+            estimatedGasUsed: estimatedGasUsed.toString(),
+        }, 'Simulated using eth_estimateGas on SwapRouter02');
+        const { estimatedGasUsedUSD, estimatedGasUsedQuoteToken, estimatedGasUsedGasToken, quoteGasAdjusted, } = await calculateGasUsed(route.quote.currency.chainId, route, estimatedGasUsed, this.v2PoolProvider, this.v3PoolProvider, this.provider, providerConfig);
+        return {
+            ...initSwapRouteFromExisting(route, this.v2PoolProvider, this.v3PoolProvider, 
+            // this.v4PoolProvider,
+            this.portionProvider, quoteGasAdjusted, estimatedGasUsed, estimatedGasUsedQuoteToken, estimatedGasUsedUSD, swapOptions, estimatedGasUsedGasToken, providerConfig),
+            simulationStatus: SimulationStatus.Succeeded,
+        };
+    }
+    adjustGasEstimate(gasLimit) {
+        var _a;
+        const estimateMultiplier = (_a = this.overrideEstimateMultiplier[this.chainId]) !== null && _a !== void 0 ? _a : DEFAULT_ESTIMATE_MULTIPLIER;
+        const adjustedGasEstimate = BigNumber.from(gasLimit)
+            .mul(estimateMultiplier * 100)
+            .div(100);
+        return adjustedGasEstimate;
+    }
+    async simulateTransaction(fromAddress, swapOptions, swapRoute, _providerConfig) {
+        const inputAmount = swapRoute.trade.inputAmount;
+        if (inputAmount.currency.isNative ||
+            (await this.checkTokenApproved(fromAddress, inputAmount, swapOptions, this.provider))) {
+            return await this.ethEstimateGas(fromAddress, swapOptions, swapRoute, _providerConfig);
+        }
+        else {
+            log.info('Token not approved, skipping simulation');
+            return {
+                ...swapRoute,
+                simulationStatus: SimulationStatus.NotApproved,
+            };
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/module/providers/eth-gas-station-info-gas-price-provider.d.ts

@@ -0,0 +1,19 @@
+import { GasPrice, IGasPriceProvider } from './gas-price-provider';
+export declare type ETHGasStationResponse = {
+    fast: number;
+    fastest: number;
+    safeLow: number;
+    average: number;
+    block_time: number;
+    blockNum: number;
+    speed: number;
+    safeLowWait: number;
+    avgWait: number;
+    fastWait: number;
+    fastestWait: number;
+};
+export declare class ETHGasStationInfoProvider extends IGasPriceProvider {
+    private url;
+    constructor(url: string);
+    getGasPrice(_latestBlockNumber: number, _requestBlockNumber?: number): Promise<GasPrice>;
+}