@fanx-protocol/smart-order-router 0.0.1

package/build/module/providers/subgraph-provider.d.ts

@@ -0,0 +1,51 @@
+import { Protocol } from '@fanx-protocol/router-sdk';
+import { ChainId, Currency, Token } from '@fanx-protocol/sdk-core';
+import { SubgraphPool } from '../routers/alpha-router/functions/get-candidate-pools';
+import { ProviderConfig } from './provider';
+export interface ISubgraphProvider<TSubgraphPool extends SubgraphPool> {
+    getPools(tokenIn?: Token, tokenOut?: Token, providerConfig?: ProviderConfig): Promise<TSubgraphPool[]>;
+}
+export declare type V3V4SubgraphPool = {
+    id: string;
+    feeTier: string;
+    liquidity: string;
+    token0: {
+        id: string;
+    };
+    token1: {
+        id: string;
+    };
+    tvlETH: number;
+    tvlUSD: number;
+};
+export declare type V3V4RawSubgraphPool = {
+    id: string;
+    feeTier: string;
+    liquidity: string;
+    token0: {
+        symbol: string;
+        id: string;
+    };
+    token1: {
+        symbol: string;
+        id: string;
+    };
+    totalValueLockedUSD: string;
+    totalValueLockedETH: string;
+    totalValueLockedUSDUntracked: string;
+};
+export declare abstract class SubgraphProvider<TRawSubgraphPool extends V3V4RawSubgraphPool, TSubgraphPool extends V3V4SubgraphPool> {
+    private protocol;
+    private chainId;
+    private retries;
+    private timeout;
+    private rollback;
+    private trackedEthThreshold;
+    private untrackedUsdThreshold;
+    private subgraphUrl?;
+    private client;
+    constructor(protocol: Protocol, chainId: ChainId, retries?: number, timeout?: number, rollback?: boolean, trackedEthThreshold?: number, untrackedUsdThreshold?: number, subgraphUrl?: string | undefined);
+    getPools(_currencyIn?: Currency, _currencyOut?: Currency, providerConfig?: ProviderConfig): Promise<TSubgraphPool[]>;
+    protected abstract subgraphQuery(blockNumber?: number): string;
+    protected abstract mapSubgraphPool(rawSubgraphPool: TRawSubgraphPool): TSubgraphPool;
+}

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

@@ -0,0 +1,113 @@
+import retry from 'async-retry';
+import Timeout from 'await-timeout';
+import { gql, GraphQLClient } from 'graphql-request';
+import _ from 'lodash';
+import { log, metric } from '../util';
+const PAGE_SIZE = 1000; // 1k is max possible query size from subgraph.
+export class SubgraphProvider {
+    constructor(protocol, chainId, retries = 2, timeout = 30000, rollback = true, trackedEthThreshold = 0.01, untrackedUsdThreshold = Number.MAX_VALUE, subgraphUrl) {
+        this.protocol = protocol;
+        this.chainId = chainId;
+        this.retries = retries;
+        this.timeout = timeout;
+        this.rollback = rollback;
+        this.trackedEthThreshold = trackedEthThreshold;
+        this.untrackedUsdThreshold = untrackedUsdThreshold;
+        this.subgraphUrl = subgraphUrl;
+        this.protocol = protocol;
+        if (!this.subgraphUrl) {
+            throw new Error(`No subgraph url for chain id: ${this.chainId}`);
+        }
+        this.client = new GraphQLClient(this.subgraphUrl);
+    }
+    async getPools(_currencyIn, _currencyOut, providerConfig) {
+        const beforeAll = Date.now();
+        let blockNumber = (providerConfig === null || providerConfig === void 0 ? void 0 : providerConfig.blockNumber)
+            ? await providerConfig.blockNumber
+            : undefined;
+        const query = gql `
+      ${this.subgraphQuery(blockNumber)}
+    `;
+        let pools = [];
+        log.info(`Getting ${this.protocol} pools from the subgraph with page size ${PAGE_SIZE}${(providerConfig === null || providerConfig === void 0 ? void 0 : providerConfig.blockNumber)
+            ? ` as of block ${providerConfig === null || providerConfig === void 0 ? void 0 : providerConfig.blockNumber}`
+            : ''}.`);
+        let retries = 0;
+        await retry(async () => {
+            const timeout = new Timeout();
+            const getPools = async () => {
+                let lastId = '';
+                let pools = [];
+                let poolsPage = [];
+                // metrics variables
+                let totalPages = 0;
+                do {
+                    totalPages += 1;
+                    const poolsResult = await this.client.request(query, {
+                        pageSize: PAGE_SIZE,
+                        id: lastId,
+                    });
+                    poolsPage = poolsResult.pools;
+                    pools = pools.concat(poolsPage);
+                    lastId = pools[pools.length - 1].id;
+                    metric.putMetric(`${this.protocol}SubgraphProvider.chain_${this.chainId}.getPools.paginate.pageSize`, poolsPage.length);
+                } while (poolsPage.length > 0);
+                metric.putMetric(`${this.protocol}SubgraphProvider.chain_${this.chainId}.getPools.paginate`, totalPages);
+                metric.putMetric(`${this.protocol}SubgraphProvider.chain_${this.chainId}.getPools.pools.length`, pools.length);
+                return pools;
+            };
+            try {
+                const getPoolsPromise = getPools();
+                const timerPromise = timeout.set(this.timeout).then(() => {
+                    throw new Error(`Timed out getting pools from subgraph: ${this.timeout}`);
+                });
+                pools = await Promise.race([getPoolsPromise, timerPromise]);
+                return;
+            }
+            catch (err) {
+                log.error({ err }, `Error fetching ${this.protocol} Subgraph Pools.`);
+                throw err;
+            }
+            finally {
+                timeout.clear();
+            }
+        }, {
+            retries: this.retries,
+            onRetry: (err, retry) => {
+                retries += 1;
+                if (this.rollback &&
+                    blockNumber &&
+                    _.includes(err.message, 'indexed up to')) {
+                    metric.putMetric(`${this.protocol}SubgraphProvider.chain_${this.chainId}.getPools.indexError`, 1);
+                    blockNumber = blockNumber - 10;
+                    log.info(`Detected subgraph indexing error. Rolled back block number to: ${blockNumber}`);
+                }
+                metric.putMetric(`${this.protocol}SubgraphProvider.chain_${this.chainId}.getPools.timeout`, 1);
+                pools = [];
+                log.info({ err }, `Failed to get pools from subgraph. Retry attempt: ${retry}`);
+            },
+        });
+        metric.putMetric(`${this.protocol}SubgraphProvider.chain_${this.chainId}.getPools.retries`, retries);
+        const untrackedPools = pools.filter((pool) => parseInt(pool.liquidity) > 0 ||
+            parseFloat(pool.totalValueLockedETH) > this.trackedEthThreshold ||
+            parseFloat(pool.totalValueLockedUSDUntracked) >
+                this.untrackedUsdThreshold);
+        metric.putMetric(`${this.protocol}SubgraphProvider.chain_${this.chainId}.getPools.untracked.length`, untrackedPools.length);
+        metric.putMetric(`${this.protocol}SubgraphProvider.chain_${this.chainId}.getPools.untracked.percent`, (untrackedPools.length / pools.length) * 100);
+        const beforeFilter = Date.now();
+        const poolsSanitized = pools
+            .filter((pool) => parseInt(pool.liquidity) > 0 ||
+            parseFloat(pool.totalValueLockedETH) > this.trackedEthThreshold)
+            .map((pool) => {
+            return this.mapSubgraphPool(pool);
+        });
+        metric.putMetric(`${this.protocol}SubgraphProvider.chain_${this.chainId}.getPools.filter.latency`, Date.now() - beforeFilter);
+        metric.putMetric(`${this.protocol}SubgraphProvider.chain_${this.chainId}.getPools.filter.length`, poolsSanitized.length);
+        metric.putMetric(`${this.protocol}SubgraphProvider.chain_${this.chainId}.getPools.filter.percent`, (poolsSanitized.length / pools.length) * 100);
+        metric.putMetric(`${this.protocol}SubgraphProvider.chain_${this.chainId}.getPools`, 1);
+        metric.putMetric(`${this.protocol}SubgraphProvider.chain_${this.chainId}.getPools.latency`, Date.now() - beforeAll);
+        log.info(`Got ${pools.length} ${this.protocol} pools from the subgraph. ${poolsSanitized.length} after filtering`);
+        return poolsSanitized;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/module/providers/swap-router-provider.d.ts

@@ -0,0 +1,30 @@
+import { ApprovalTypes } from '@fanx-protocol/router-sdk';
+import { ChainId, Currency, CurrencyAmount } from '@fanx-protocol/sdk-core';
+import { IMulticallProvider } from './multicall-provider';
+declare type TokenApprovalTypes = {
+    approvalTokenIn: ApprovalTypes;
+    approvalTokenOut: ApprovalTypes;
+};
+/**
+ * Provider for accessing the SwapRouter02 Contract .
+ *
+ * @export
+ * @interface IRouterProvider
+ */
+export interface ISwapRouterProvider {
+    /**
+     * Get the approval method needed for each token. Throws an error if either query fails.
+     *
+     * @param tokenInAmount The Currency Amount of tokenIn needed by the user
+     * @param tokenOutAmount The Currency Amount of tokenOut needed by the user
+     * @returns the Approval Types for each token.
+     */
+    getApprovalType(tokenInAmount: CurrencyAmount<Currency>, tokenOutAmount: CurrencyAmount<Currency>): Promise<TokenApprovalTypes>;
+}
+export declare class SwapRouterProvider implements ISwapRouterProvider {
+    protected multicall2Provider: IMulticallProvider;
+    protected chainId: ChainId;
+    constructor(multicall2Provider: IMulticallProvider, chainId: ChainId);
+    getApprovalType(tokenInAmount: CurrencyAmount<Currency>, tokenOutAmount: CurrencyAmount<Currency>): Promise<TokenApprovalTypes>;
+}
+export {};

package/build/module/providers/swap-router-provider.js

@@ -0,0 +1,38 @@
+import { SwapRouter02__factory } from '../types/other/factories/SwapRouter02__factory';
+import { log, SWAP_ROUTER_02_ADDRESSES } from '../util';
+export class SwapRouterProvider {
+    constructor(multicall2Provider, chainId) {
+        this.multicall2Provider = multicall2Provider;
+        this.chainId = chainId;
+    }
+    async getApprovalType(tokenInAmount, tokenOutAmount) {
+        var _a, _b;
+        const functionParams = [
+            [
+                tokenInAmount.currency.wrapped.address,
+                tokenInAmount.quotient.toString(),
+            ],
+            [
+                tokenOutAmount.currency.wrapped.address,
+                tokenOutAmount.quotient.toString(),
+            ],
+        ];
+        const tx = await this.multicall2Provider.callSameFunctionOnContractWithMultipleParams({
+            address: SWAP_ROUTER_02_ADDRESSES(this.chainId),
+            contractInterface: SwapRouter02__factory.createInterface(),
+            functionName: 'getApprovalType',
+            functionParams,
+        });
+        if (!((_a = tx.results[0]) === null || _a === void 0 ? void 0 : _a.success) || !((_b = tx.results[1]) === null || _b === void 0 ? void 0 : _b.success)) {
+            log.info({ results: tx.results }, 'Failed to get approval type from swap router for token in or token out');
+            throw new Error('Failed to get approval type from swap router for token in or token out');
+        }
+        const { result: approvalTokenIn } = tx.results[0];
+        const { result: approvalTokenOut } = tx.results[1];
+        return {
+            approvalTokenIn: approvalTokenIn[0],
+            approvalTokenOut: approvalTokenOut[0],
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3dhcC1yb3V0ZXItcHJvdmlkZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvcHJvdmlkZXJzL3N3YXAtcm91dGVyLXByb3ZpZGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLGdEQUFnRCxDQUFDO0FBQ3ZGLE9BQU8sRUFBRSxHQUFHLEVBQUUsd0JBQXdCLEVBQUUsTUFBTSxTQUFTLENBQUM7QUE2QnhELE1BQU0sT0FBTyxrQkFBa0I7SUFDN0IsWUFDWSxrQkFBc0MsRUFDdEMsT0FBZ0I7UUFEaEIsdUJBQWtCLEdBQWxCLGtCQUFrQixDQUFvQjtRQUN0QyxZQUFPLEdBQVAsT0FBTyxDQUFTO0lBQ3pCLENBQUM7SUFFRyxLQUFLLENBQUMsZUFBZSxDQUMxQixhQUF1QyxFQUN2QyxjQUF3Qzs7UUFFeEMsTUFBTSxjQUFjLEdBQXVCO1lBQ3pDO2dCQUNFLGFBQWEsQ0FBQyxRQUFRLENBQUMsT0FBTyxDQUFDLE9BQU87Z0JBQ3RDLGFBQWEsQ0FBQyxRQUFRLENBQUMsUUFBUSxFQUFFO2FBQ2xDO1lBQ0Q7Z0JBQ0UsY0FBYyxDQUFDLFFBQVEsQ0FBQyxPQUFPLENBQUMsT0FBTztnQkFDdkMsY0FBYyxDQUFDLFFBQVEsQ0FBQyxRQUFRLEVBQUU7YUFDbkM7U0FDRixDQUFDO1FBRUYsTUFBTSxFQUFFLEdBQ04sTUFBTSxJQUFJLENBQUMsa0JBQWtCLENBQUMsNENBQTRDLENBR3hFO1lBQ0EsT0FBTyxFQUFFLHdCQUF3QixDQUFDLElBQUksQ0FBQyxPQUFPLENBQUM7WUFDL0MsaUJBQWlCLEVBQUUscUJBQXFCLENBQUMsZUFBZSxFQUFFO1lBQzFELFlBQVksRUFBRSxpQkFBaUI7WUFDL0IsY0FBYztTQUNmLENBQUMsQ0FBQztRQUVMLElBQUksQ0FBQyxDQUFBLE1BQUEsRUFBRSxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsMENBQUUsT0FBTyxDQUFBLElBQUksQ0FBQyxDQUFBLE1BQUEsRUFBRSxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsMENBQUUsT0FBTyxDQUFBLEVBQUU7WUFDdEQsR0FBRyxDQUFDLElBQUksQ0FDTixFQUFFLE9BQU8sRUFBRSxFQUFFLENBQUMsT0FBTyxFQUFFLEVBQ3ZCLHdFQUF3RSxDQUN6RSxDQUFDO1lBQ0YsTUFBTSxJQUFJLEtBQUssQ0FDYix3RUFBd0UsQ0FDekUsQ0FBQztTQUNIO1FBRUQsTUFBTSxFQUFFLE1BQU0sRUFBRSxlQUFlLEVBQUUsR0FBRyxFQUFFLENBQUMsT0FBUSxDQUFDLENBQUMsQ0FBQyxDQUFDO1FBQ25ELE1BQU0sRUFBRSxNQUFNLEVBQUUsZ0JBQWdCLEVBQUUsR0FBRyxFQUFFLENBQUMsT0FBUSxDQUFDLENBQUMsQ0FBQyxDQUFDO1FBRXBELE9BQU87WUFDTCxlQUFlLEVBQUUsZUFBZSxDQUFDLENBQUMsQ0FBQztZQUNuQyxnQkFBZ0IsRUFBRSxnQkFBZ0IsQ0FBQyxDQUFDLENBQUM7U0FDdEMsQ0FBQztJQUNKLENBQUM7Q0FDRiJ9

package/build/module/providers/token-fee-fetcher.d.ts

@@ -0,0 +1,31 @@
+import { BigNumber } from '@ethersproject/bignumber';
+import { BaseProvider } from '@ethersproject/providers';
+import { ChainId } from '@fanx-protocol/sdk-core';
+import { ProviderConfig } from './provider';
+export declare const DEFAULT_TOKEN_FEE_RESULT: {
+    buyFeeBps: BigNumber;
+    sellFeeBps: BigNumber;
+};
+declare type Address = string;
+export declare type TokenFeeResult = {
+    buyFeeBps?: BigNumber;
+    sellFeeBps?: BigNumber;
+    feeTakenOnTransfer?: boolean;
+    externalTransferFailed?: boolean;
+    sellReverted?: boolean;
+};
+export declare type TokenFeeMap = Record<Address, TokenFeeResult>;
+export interface ITokenFeeFetcher {
+    fetchFees(addresses: Address[], providerConfig?: ProviderConfig): Promise<TokenFeeMap>;
+}
+export declare class OnChainTokenFeeFetcher implements ITokenFeeFetcher {
+    private chainId;
+    private tokenFeeAddress;
+    private gasLimitPerCall;
+    private amountToFlashBorrow;
+    private BASE_TOKEN;
+    private readonly contract;
+    constructor(chainId: ChainId, rpcProvider: BaseProvider, tokenFeeAddress?: string, gasLimitPerCall?: number, amountToFlashBorrow?: string);
+    fetchFees(addresses: Address[], providerConfig?: ProviderConfig): Promise<TokenFeeMap>;
+}
+export {};

package/build/module/providers/token-fee-fetcher.js

@@ -0,0 +1,104 @@
+import { BigNumber } from '@ethersproject/bignumber';
+import { ChainId } from '@fanx-protocol/sdk-core';
+import { TokenFeeDetector__factory } from '../types/other/factories/TokenFeeDetector__factory';
+import { log, metric, MetricLoggerUnit, WRAPPED_NATIVE_CURRENCY, } from '../util';
+const DEFAULT_TOKEN_BUY_FEE_BPS = BigNumber.from(0);
+const DEFAULT_TOKEN_SELL_FEE_BPS = BigNumber.from(0);
+// on detector failure, assume no fee
+export const DEFAULT_TOKEN_FEE_RESULT = {
+    buyFeeBps: DEFAULT_TOKEN_BUY_FEE_BPS,
+    sellFeeBps: DEFAULT_TOKEN_SELL_FEE_BPS,
+};
+// address at which the FeeDetector lens is deployed
+const FEE_DETECTOR_ADDRESS = (chainId) => {
+    switch (chainId) {
+        // case ChainId.MAINNET:
+        //   return '0xbc708B192552e19A088b4C4B8772aEeA83bCf760';
+        // case ChainId.OPTIMISM:
+        //   return '0x95aDC98A949dCD94645A8cD56830D86e4Cf34Eff';
+        // case ChainId.BNB:
+        //   return '0xCF6220e4496B091a6b391D48e770f1FbaC63E740';
+        // case ChainId.POLYGON:
+        //   return '0xC988e19819a63C0e487c6Ad8d6668Ac773923BF2';
+        // case ChainId.BASE:
+        //   return '0xCF6220e4496B091a6b391D48e770f1FbaC63E740';
+        // case ChainId.ARBITRUM_ONE:
+        //   return '0x37324D81e318260DC4f0fCb68035028eFdE6F50e';
+        // case ChainId.CELO:
+        //   return '0x8eEa35913DdeD795001562f9bA5b282d3ac04B60';
+        // case ChainId.AVALANCHE:
+        //   return '0x8269d47c4910B8c87789aA0eC128C11A8614dfC8';
+        case ChainId.SPICY:
+            return '0xEC2e5a51C31AA42fE95D138807Ce91cE4593E5Ee';
+        default:
+            // just default to mainnet contract
+            return '0xbc708B192552e19A088b4C4B8772aEeA83bCf760';
+    }
+};
+// Amount has to be big enough to avoid rounding errors, but small enough that
+// most v2 pools will have at least this many token units
+// 100000 is the smallest number that avoids rounding errors in bps terms
+// 10000 was not sufficient due to rounding errors for rebase token (e.g. stETH)
+const AMOUNT_TO_FLASH_BORROW = '100000';
+// 1M gas limit per validate call, should cover most swap cases
+const GAS_LIMIT_PER_VALIDATE = 1000000;
+export class OnChainTokenFeeFetcher {
+    constructor(chainId, rpcProvider, tokenFeeAddress = FEE_DETECTOR_ADDRESS(chainId), gasLimitPerCall = GAS_LIMIT_PER_VALIDATE, amountToFlashBorrow = AMOUNT_TO_FLASH_BORROW) {
+        var _a;
+        this.chainId = chainId;
+        this.tokenFeeAddress = tokenFeeAddress;
+        this.gasLimitPerCall = gasLimitPerCall;
+        this.amountToFlashBorrow = amountToFlashBorrow;
+        this.BASE_TOKEN = (_a = WRAPPED_NATIVE_CURRENCY[this.chainId]) === null || _a === void 0 ? void 0 : _a.address;
+        this.contract = TokenFeeDetector__factory.connect(this.tokenFeeAddress, rpcProvider);
+    }
+    async fetchFees(addresses, providerConfig) {
+        const tokenToResult = {};
+        const addressesWithoutBaseToken = addresses.filter((address) => address.toLowerCase() !== this.BASE_TOKEN.toLowerCase());
+        const functionParams = addressesWithoutBaseToken.map((address) => [
+            address,
+            this.BASE_TOKEN,
+            this.amountToFlashBorrow,
+        ]);
+        const results = await Promise.all(functionParams.map(async ([address, baseToken, amountToBorrow]) => {
+            try {
+                // We use the validate function instead of batchValidate to avoid poison pill problem.
+                // One token that consumes too much gas could cause the entire batch to fail.
+                const feeResult = await this.contract.callStatic.validate(address, baseToken, amountToBorrow, {
+                    gasLimit: this.gasLimitPerCall,
+                    blockTag: providerConfig === null || providerConfig === void 0 ? void 0 : providerConfig.blockNumber,
+                });
+                metric.putMetric('TokenFeeFetcherFetchFeesSuccess', 1, MetricLoggerUnit.Count);
+                return { address, ...feeResult };
+            }
+            catch (err) {
+                log.error({ err }, `Error calling validate on-chain for token ${address}`);
+                metric.putMetric('TokenFeeFetcherFetchFeesFailure', 1, MetricLoggerUnit.Count);
+                // in case of FOT token fee fetch failure, we return null
+                // so that they won't get returned from the token-fee-fetcher
+                // and thus no fee will be applied, and the cache won't cache on FOT tokens with failed fee fetching
+                return {
+                    address,
+                    buyFeeBps: undefined,
+                    sellFeeBps: undefined,
+                    feeTakenOnTransfer: false,
+                    externalTransferFailed: false,
+                    sellReverted: false,
+                };
+            }
+        }));
+        results.forEach(({ address, buyFeeBps, sellFeeBps, feeTakenOnTransfer, externalTransferFailed, sellReverted, }) => {
+            if (buyFeeBps || sellFeeBps) {
+                tokenToResult[address] = {
+                    buyFeeBps,
+                    sellFeeBps,
+                    feeTakenOnTransfer,
+                    externalTransferFailed,
+                    sellReverted,
+                };
+            }
+        });
+        return tokenToResult;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,31 @@
+import { ChainId, Currency } from '@fanx-protocol/sdk-core';
+import { ICache } from './cache';
+import { ProviderConfig } from './provider';
+import { ITokenFeeFetcher, TokenFeeResult } from './token-fee-fetcher';
+import { TokenValidationResult } from './token-validator-provider';
+export declare const DEFAULT_TOKEN_PROPERTIES_RESULT: TokenPropertiesResult;
+export declare const POSITIVE_CACHE_ENTRY_TTL = 1200;
+export declare const NEGATIVE_CACHE_ENTRY_TTL = 1200;
+declare type Address = string;
+export declare type TokenPropertiesResult = {
+    tokenFeeResult?: TokenFeeResult;
+    tokenValidationResult?: TokenValidationResult;
+};
+export declare type TokenPropertiesMap = Record<Address, TokenPropertiesResult>;
+export interface ITokenPropertiesProvider {
+    getTokensProperties(currencies: Currency[], providerConfig?: ProviderConfig): Promise<TokenPropertiesMap>;
+}
+export declare class TokenPropertiesProvider implements ITokenPropertiesProvider {
+    private chainId;
+    private tokenPropertiesCache;
+    private tokenFeeFetcher;
+    private allowList;
+    private positiveCacheEntryTTL;
+    private negativeCacheEntryTTL;
+    private CACHE_KEY;
+    constructor(chainId: ChainId, tokenPropertiesCache: ICache<TokenPropertiesResult>, tokenFeeFetcher: ITokenFeeFetcher, allowList?: Set<string>, positiveCacheEntryTTL?: number, negativeCacheEntryTTL?: number);
+    getTokensProperties(currencies: Currency[], providerConfig?: ProviderConfig): Promise<TokenPropertiesMap>;
+    private buildAddressesRaw;
+    private buildAddressesCacheKeys;
+}
+export {};

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

@@ -0,0 +1,114 @@
+import { getAddressLowerCase, log, metric, MetricLoggerUnit } from '../util';
+import { DEFAULT_TOKEN_FEE_RESULT, } from './token-fee-fetcher';
+import { DEFAULT_ALLOWLIST, TokenValidationResult, } from './token-validator-provider';
+export const DEFAULT_TOKEN_PROPERTIES_RESULT = {
+    tokenFeeResult: DEFAULT_TOKEN_FEE_RESULT,
+};
+export const POSITIVE_CACHE_ENTRY_TTL = 1200; // 20 minutes in seconds
+export const NEGATIVE_CACHE_ENTRY_TTL = 1200; // 20 minutes in seconds
+export class TokenPropertiesProvider {
+    constructor(chainId, tokenPropertiesCache, tokenFeeFetcher, allowList = DEFAULT_ALLOWLIST, positiveCacheEntryTTL = POSITIVE_CACHE_ENTRY_TTL, negativeCacheEntryTTL = NEGATIVE_CACHE_ENTRY_TTL) {
+        this.chainId = chainId;
+        this.tokenPropertiesCache = tokenPropertiesCache;
+        this.tokenFeeFetcher = tokenFeeFetcher;
+        this.allowList = allowList;
+        this.positiveCacheEntryTTL = positiveCacheEntryTTL;
+        this.negativeCacheEntryTTL = negativeCacheEntryTTL;
+        this.CACHE_KEY = (chainId, address) => `token-properties-${chainId}-${address}`;
+    }
+    async getTokensProperties(currencies, providerConfig) {
+        const tokenToResult = {};
+        if (!(providerConfig === null || providerConfig === void 0 ? void 0 : providerConfig.enableFeeOnTransferFeeFetching)) {
+            return tokenToResult;
+        }
+        const addressesToFetchFeesOnchain = [];
+        const addressesRaw = this.buildAddressesRaw(currencies);
+        const addressesCacheKeys = this.buildAddressesCacheKeys(currencies);
+        const tokenProperties = await this.tokenPropertiesCache.batchGet(addressesCacheKeys);
+        // Check if we have cached token validation results for any tokens.
+        for (const address of addressesRaw) {
+            const cachedValue = tokenProperties[this.CACHE_KEY(this.chainId, address.toLowerCase())];
+            if (cachedValue) {
+                metric.putMetric('TokenPropertiesProviderBatchGetCacheHit', 1, MetricLoggerUnit.Count);
+                const tokenFee = cachedValue.tokenFeeResult;
+                const tokenFeeResultExists = tokenFee && (tokenFee.buyFeeBps || tokenFee.sellFeeBps);
+                if (tokenFeeResultExists) {
+                    metric.putMetric(`TokenPropertiesProviderCacheHitTokenFeeResultExists${tokenFeeResultExists}`, 1, MetricLoggerUnit.Count);
+                }
+                else {
+                    metric.putMetric(`TokenPropertiesProviderCacheHitTokenFeeResultNotExists`, 1, MetricLoggerUnit.Count);
+                }
+                tokenToResult[address] = cachedValue;
+            }
+            else if (this.allowList.has(address)) {
+                tokenToResult[address] = {
+                    tokenValidationResult: TokenValidationResult.UNKN,
+                };
+            }
+            else {
+                addressesToFetchFeesOnchain.push(address);
+            }
+        }
+        if (addressesToFetchFeesOnchain.length > 0) {
+            let tokenFeeMap = {};
+            try {
+                tokenFeeMap = await this.tokenFeeFetcher.fetchFees(addressesToFetchFeesOnchain, providerConfig);
+            }
+            catch (err) {
+                log.error({ err }, `Error fetching fees for tokens ${addressesToFetchFeesOnchain}`);
+            }
+            await Promise.all(addressesToFetchFeesOnchain.map((address) => {
+                const tokenFee = tokenFeeMap[address];
+                const tokenFeeResultExists = tokenFee && (tokenFee.buyFeeBps || tokenFee.sellFeeBps);
+                if (tokenFeeResultExists) {
+                    // we will leverage the metric to log the token fee result, if it exists
+                    // the idea is that the token fee should not differ by too much across tokens,
+                    // so that we can accurately log the token fee for a particular quote request (without breaching metrics dimensionality limit)
+                    // in the form of metrics.
+                    // if we log as logging, given prod traffic volume, the logging volume will be high.
+                    metric.putMetric(`TokenPropertiesProviderTokenFeeResultCacheMissExists${tokenFeeResultExists}`, 1, MetricLoggerUnit.Count);
+                    const tokenPropertiesResult = {
+                        tokenFeeResult: tokenFee,
+                        tokenValidationResult: TokenValidationResult.FOT,
+                    };
+                    tokenToResult[address] = tokenPropertiesResult;
+                    metric.putMetric('TokenPropertiesProviderBatchGetCacheMiss', 1, MetricLoggerUnit.Count);
+                    // update cache concurrently
+                    // at this point, we are confident that the tokens are FOT, so we can hardcode the validation result
+                    return this.tokenPropertiesCache.set(this.CACHE_KEY(this.chainId, address), tokenPropertiesResult, this.positiveCacheEntryTTL);
+                }
+                else {
+                    metric.putMetric(`TokenPropertiesProviderTokenFeeResultCacheMissNotExists`, 1, MetricLoggerUnit.Count);
+                    const tokenPropertiesResult = {
+                        tokenFeeResult: undefined,
+                        tokenValidationResult: undefined,
+                    };
+                    tokenToResult[address] = tokenPropertiesResult;
+                    return this.tokenPropertiesCache.set(this.CACHE_KEY(this.chainId, address), tokenPropertiesResult, this.negativeCacheEntryTTL);
+                }
+            }));
+        }
+        return tokenToResult;
+    }
+    buildAddressesRaw(currencies) {
+        const addressesRaw = new Set();
+        for (const currency of currencies) {
+            const address = getAddressLowerCase(currency);
+            if (!addressesRaw.has(address)) {
+                addressesRaw.add(address);
+            }
+        }
+        return addressesRaw;
+    }
+    buildAddressesCacheKeys(currencies) {
+        const addressesCacheKeys = new Set();
+        for (const currency of currencies) {
+            const addressCacheKey = this.CACHE_KEY(this.chainId, getAddressLowerCase(currency));
+            if (!addressesCacheKeys.has(addressCacheKey)) {
+                addressesCacheKeys.add(addressCacheKey);
+            }
+        }
+        return addressesCacheKeys;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9rZW4tcHJvcGVydGllcy1wcm92aWRlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9wcm92aWRlcnMvdG9rZW4tcHJvcGVydGllcy1wcm92aWRlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFHQSxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsR0FBRyxFQUFFLE1BQU0sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLFNBQVMsQ0FBQztBQUk3RSxPQUFPLEVBQ0wsd0JBQXdCLEdBSXpCLE1BQU0scUJBQXFCLENBQUM7QUFDN0IsT0FBTyxFQUNMLGlCQUFpQixFQUNqQixxQkFBcUIsR0FDdEIsTUFBTSw0QkFBNEIsQ0FBQztBQUVwQyxNQUFNLENBQUMsTUFBTSwrQkFBK0IsR0FBMEI7SUFDcEUsY0FBYyxFQUFFLHdCQUF3QjtDQUN6QyxDQUFDO0FBQ0YsTUFBTSxDQUFDLE1BQU0sd0JBQXdCLEdBQUcsSUFBSSxDQUFDLENBQUMsd0JBQXdCO0FBQ3RFLE1BQU0sQ0FBQyxNQUFNLHdCQUF3QixHQUFHLElBQUksQ0FBQyxDQUFDLHdCQUF3QjtBQWdCdEUsTUFBTSxPQUFPLHVCQUF1QjtJQUlsQyxZQUNVLE9BQWdCLEVBQ2hCLG9CQUFtRCxFQUNuRCxlQUFpQyxFQUNqQyxZQUFZLGlCQUFpQixFQUM3Qix3QkFBd0Isd0JBQXdCLEVBQ2hELHdCQUF3Qix3QkFBd0I7UUFMaEQsWUFBTyxHQUFQLE9BQU8sQ0FBUztRQUNoQix5QkFBb0IsR0FBcEIsb0JBQW9CLENBQStCO1FBQ25ELG9CQUFlLEdBQWYsZUFBZSxDQUFrQjtRQUNqQyxjQUFTLEdBQVQsU0FBUyxDQUFvQjtRQUM3QiwwQkFBcUIsR0FBckIscUJBQXFCLENBQTJCO1FBQ2hELDBCQUFxQixHQUFyQixxQkFBcUIsQ0FBMkI7UUFUbEQsY0FBUyxHQUFHLENBQUMsT0FBZ0IsRUFBRSxPQUFlLEVBQUUsRUFBRSxDQUN4RCxvQkFBb0IsT0FBTyxJQUFJLE9BQU8sRUFBRSxDQUFDO0lBU3hDLENBQUM7SUFFRyxLQUFLLENBQUMsbUJBQW1CLENBQzlCLFVBQXNCLEVBQ3RCLGNBQStCO1FBRS9CLE1BQU0sYUFBYSxHQUF1QixFQUFFLENBQUM7UUFFN0MsSUFBSSxDQUFDLENBQUEsY0FBYyxhQUFkLGNBQWMsdUJBQWQsY0FBYyxDQUFFLDhCQUE4QixDQUFBLEVBQUU7WUFDbkQsT0FBTyxhQUFhLENBQUM7U0FDdEI7UUFFRCxNQUFNLDJCQUEyQixHQUFhLEVBQUUsQ0FBQztRQUNqRCxNQUFNLFlBQVksR0FBRyxJQUFJLENBQUMsaUJBQWlCLENBQUMsVUFBVSxDQUFDLENBQUM7UUFDeEQsTUFBTSxrQkFBa0IsR0FBRyxJQUFJLENBQUMsdUJBQXVCLENBQUMsVUFBVSxDQUFDLENBQUM7UUFFcEUsTUFBTSxlQUFlLEdBQUcsTUFBTSxJQUFJLENBQUMsb0JBQW9CLENBQUMsUUFBUSxDQUM5RCxrQkFBa0IsQ0FDbkIsQ0FBQztRQUVGLG1FQUFtRTtRQUNuRSxLQUFLLE1BQU0sT0FBTyxJQUFJLFlBQVksRUFBRTtZQUNsQyxNQUFNLFdBQVcsR0FDZixlQUFlLENBQUMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxJQUFJLENBQUMsT0FBTyxFQUFFLE9BQU8sQ0FBQyxXQUFXLEVBQUUsQ0FBQyxDQUFDLENBQUM7WUFDdkUsSUFBSSxXQUFXLEVBQUU7Z0JBQ2YsTUFBTSxDQUFDLFNBQVMsQ0FDZCx5Q0FBeUMsRUFDekMsQ0FBQyxFQUNELGdCQUFnQixDQUFDLEtBQUssQ0FDdkIsQ0FBQztnQkFDRixNQUFNLFFBQVEsR0FBRyxXQUFXLENBQUMsY0FBYyxDQUFDO2dCQUM1QyxNQUFNLG9CQUFvQixHQUN4QixRQUFRLElBQUksQ0FBQyxRQUFRLENBQUMsU0FBUyxJQUFJLFFBQVEsQ0FBQyxVQUFVLENBQUMsQ0FBQztnQkFFMUQsSUFBSSxvQkFBb0IsRUFBRTtvQkFDeEIsTUFBTSxDQUFDLFNBQVMsQ0FDZCxzREFBc0Qsb0JBQW9CLEVBQUUsRUFDNUUsQ0FBQyxFQUNELGdCQUFnQixDQUFDLEtBQUssQ0FDdkIsQ0FBQztpQkFDSDtxQkFBTTtvQkFDTCxNQUFNLENBQUMsU0FBUyxDQUNkLHdEQUF3RCxFQUN4RCxDQUFDLEVBQ0QsZ0JBQWdCLENBQUMsS0FBSyxDQUN2QixDQUFDO2lCQUNIO2dCQUVELGFBQWEsQ0FBQyxPQUFPLENBQUMsR0FBRyxXQUFXLENBQUM7YUFDdEM7aUJBQU0sSUFBSSxJQUFJLENBQUMsU0FBUyxDQUFDLEdBQUcsQ0FBQyxPQUFPLENBQUMsRUFBRTtnQkFDdEMsYUFBYSxDQUFDLE9BQU8sQ0FBQyxHQUFHO29CQUN2QixxQkFBcUIsRUFBRSxxQkFBcUIsQ0FBQyxJQUFJO2lCQUNsRCxDQUFDO2FBQ0g7aUJBQU07Z0JBQ0wsMkJBQTJCLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxDQUFDO2FBQzNDO1NBQ0Y7UUFFRCxJQUFJLDJCQUEyQixDQUFDLE1BQU0sR0FBRyxDQUFDLEVBQUU7WUFDMUMsSUFBSSxXQUFXLEdBQWdCLEVBQUUsQ0FBQztZQUVsQyxJQUFJO2dCQUNGLFdBQVcsR0FBRyxNQUFNLElBQUksQ0FBQyxlQUFlLENBQUMsU0FBUyxDQUNoRCwyQkFBMkIsRUFDM0IsY0FBYyxDQUNmLENBQUM7YUFDSDtZQUFDLE9BQU8sR0FBRyxFQUFFO2dCQUNaLEdBQUcsQ0FBQyxLQUFLLENBQ1AsRUFBRSxHQUFHLEVBQUUsRUFDUCxrQ0FBa0MsMkJBQTJCLEVBQUUsQ0FDaEUsQ0FBQzthQUNIO1lBRUQsTUFBTSxPQUFPLENBQUMsR0FBRyxDQUNmLDJCQUEyQixDQUFDLEdBQUcsQ0FBQyxDQUFDLE9BQU8sRUFBRSxFQUFFO2dCQUMxQyxNQUFNLFFBQVEsR0FBRyxXQUFXLENBQUMsT0FBTyxDQUFDLENBQUM7Z0JBQ3RDLE1BQU0sb0JBQW9CLEdBQ3hCLFFBQVEsSUFBSSxDQUFDLFFBQVEsQ0FBQyxTQUFTLElBQUksUUFBUSxDQUFDLFVBQVUsQ0FBQyxDQUFDO2dCQUUxRCxJQUFJLG9CQUFvQixFQUFFO29CQUN4Qix3RUFBd0U7b0JBQ3hFLDhFQUE4RTtvQkFDOUUsOEhBQThIO29CQUM5SCwwQkFBMEI7b0JBQzFCLG9GQUFvRjtvQkFDcEYsTUFBTSxDQUFDLFNBQVMsQ0FDZCx1REFBdUQsb0JBQW9CLEVBQUUsRUFDN0UsQ0FBQyxFQUNELGdCQUFnQixDQUFDLEtBQUssQ0FDdkIsQ0FBQztvQkFFRixNQUFNLHFCQUFxQixHQUFHO3dCQUM1QixjQUFjLEVBQUUsUUFBUTt3QkFDeEIscUJBQXFCLEVBQUUscUJBQXFCLENBQUMsR0FBRztxQkFDakQsQ0FBQztvQkFDRixhQUFhLENBQUMsT0FBTyxDQUFDLEdBQUcscUJBQXFCLENBQUM7b0JBRS9DLE1BQU0sQ0FBQyxTQUFTLENBQ2QsMENBQTBDLEVBQzFDLENBQUMsRUFDRCxnQkFBZ0IsQ0FBQyxLQUFLLENBQ3ZCLENBQUM7b0JBRUYsNEJBQTRCO29CQUM1QixvR0FBb0c7b0JBQ3BHLE9BQU8sSUFBSSxDQUFDLG9CQUFvQixDQUFDLEdBQUcsQ0FDbEMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxJQUFJLENBQUMsT0FBTyxFQUFFLE9BQU8sQ0FBQyxFQUNyQyxxQkFBcUIsRUFDckIsSUFBSSxDQUFDLHFCQUFxQixDQUMzQixDQUFDO2lCQUNIO3FCQUFNO29CQUNMLE1BQU0sQ0FBQyxTQUFTLENBQ2QseURBQXlELEVBQ3pELENBQUMsRUFDRCxnQkFBZ0IsQ0FBQyxLQUFLLENBQ3ZCLENBQUM7b0JBRUYsTUFBTSxxQkFBcUIsR0FBRzt3QkFDNUIsY0FBYyxFQUFFLFNBQVM7d0JBQ3pCLHFCQUFxQixFQUFFLFNBQVM7cUJBQ2pDLENBQUM7b0JBQ0YsYUFBYSxDQUFDLE9BQU8sQ0FBQyxHQUFHLHFCQUFxQixDQUFDO29CQUUvQyxPQUFPLElBQUksQ0FBQyxvQkFBb0IsQ0FBQyxHQUFHLENBQ2xDLElBQUksQ0FBQyxTQUFTLENBQUMsSUFBSSxDQUFDLE9BQU8sRUFBRSxPQUFPLENBQUMsRUFDckMscUJBQXFCLEVBQ3JCLElBQUksQ0FBQyxxQkFBcUIsQ0FDM0IsQ0FBQztpQkFDSDtZQUNILENBQUMsQ0FBQyxDQUNILENBQUM7U0FDSDtRQUVELE9BQU8sYUFBYSxDQUFDO0lBQ3ZCLENBQUM7SUFFTyxpQkFBaUIsQ0FBQyxVQUFzQjtRQUM5QyxNQUFNLFlBQVksR0FBRyxJQUFJLEdBQUcsRUFBVSxDQUFDO1FBRXZDLEtBQUssTUFBTSxRQUFRLElBQUksVUFBVSxFQUFFO1lBQ2pDLE1BQU0sT0FBTyxHQUFHLG1CQUFtQixDQUFDLFFBQVEsQ0FBQyxDQUFDO1lBQzlDLElBQUksQ0FBQyxZQUFZLENBQUMsR0FBRyxDQUFDLE9BQU8sQ0FBQyxFQUFFO2dCQUM5QixZQUFZLENBQUMsR0FBRyxDQUFDLE9BQU8sQ0FBQyxDQUFDO2FBQzNCO1NBQ0Y7UUFFRCxPQUFPLFlBQVksQ0FBQztJQUN0QixDQUFDO0lBRU8sdUJBQXVCLENBQUMsVUFBc0I7UUFDcEQsTUFBTSxrQkFBa0IsR0FBRyxJQUFJLEdBQUcsRUFBVSxDQUFDO1FBRTdDLEtBQUssTUFBTSxRQUFRLElBQUksVUFBVSxFQUFFO1lBQ2pDLE1BQU0sZUFBZSxHQUFHLElBQUksQ0FBQyxTQUFTLENBQ3BDLElBQUksQ0FBQyxPQUFPLEVBQ1osbUJBQW1CLENBQUMsUUFBUSxDQUFDLENBQzlCLENBQUM7WUFDRixJQUFJLENBQUMsa0JBQWtCLENBQUMsR0FBRyxDQUFDLGVBQWUsQ0FBQyxFQUFFO2dCQUM1QyxrQkFBa0IsQ0FBQyxHQUFHLENBQUMsZUFBZSxDQUFDLENBQUM7YUFDekM7U0FDRjtRQUVELE9BQU8sa0JBQWtCLENBQUM7SUFDNUIsQ0FBQztDQUNGIn0=

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

@@ -0,0 +1,38 @@
+import { ChainId, Token } from '@fanx-protocol/sdk-core';
+import { IMulticallProvider } from './multicall-provider';
+import { ProviderConfig } from './provider';
+/**
+ * Provider for getting token data.
+ *
+ * @export
+ * @interface ITokenProvider
+ */
+export interface ITokenProvider {
+    /**
+     * Gets the token at each address. Any addresses that are not valid ERC-20 are ignored.
+     *
+     * @param addresses The token addresses to get.
+     * @param [providerConfig] The provider config.
+     * @returns A token accessor with methods for accessing the tokens.
+     */
+    getTokens(addresses: string[], providerConfig?: ProviderConfig): Promise<TokenAccessor>;
+}
+export declare type TokenAccessor = {
+    getTokenByAddress(address: string): Token | undefined;
+    getTokenBySymbol(symbol: string): Token | undefined;
+    getAllTokens: () => Token[];
+};
+export declare const USDC_CHILIZ: Token;
+export declare const USDC_SPICY: Token;
+export declare class TokenProvider implements ITokenProvider {
+    private chainId;
+    protected multicall2Provider: IMulticallProvider;
+    constructor(chainId: ChainId, multicall2Provider: IMulticallProvider);
+    private getTokenSymbol;
+    private getTokenDecimals;
+    getTokens(_addresses: string[], providerConfig?: ProviderConfig): Promise<TokenAccessor>;
+}
+export declare const DAI_ON: (chainId: ChainId) => Token;
+export declare const USDT_ON: (chainId: ChainId) => Token;
+export declare const USDC_ON: (chainId: ChainId) => Token;
+export declare const WNATIVE_ON: (chainId: ChainId) => Token;