@fanx-protocol/smart-order-router 0.0.1

package/build/main/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/main/providers/subgraph-provider.js

@@ -0,0 +1,120 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubgraphProvider = void 0;
+const async_retry_1 = __importDefault(require("async-retry"));
+const await_timeout_1 = __importDefault(require("await-timeout"));
+const graphql_request_1 = require("graphql-request");
+const lodash_1 = __importDefault(require("lodash"));
+const util_1 = require("../util");
+const PAGE_SIZE = 1000; // 1k is max possible query size from subgraph.
+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 graphql_request_1.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 = (0, graphql_request_1.gql) `
+      ${this.subgraphQuery(blockNumber)}
+    `;
+        let pools = [];
+        util_1.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 (0, async_retry_1.default)(async () => {
+            const timeout = new await_timeout_1.default();
+            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;
+                    util_1.metric.putMetric(`${this.protocol}SubgraphProvider.chain_${this.chainId}.getPools.paginate.pageSize`, poolsPage.length);
+                } while (poolsPage.length > 0);
+                util_1.metric.putMetric(`${this.protocol}SubgraphProvider.chain_${this.chainId}.getPools.paginate`, totalPages);
+                util_1.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) {
+                util_1.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 &&
+                    lodash_1.default.includes(err.message, 'indexed up to')) {
+                    util_1.metric.putMetric(`${this.protocol}SubgraphProvider.chain_${this.chainId}.getPools.indexError`, 1);
+                    blockNumber = blockNumber - 10;
+                    util_1.log.info(`Detected subgraph indexing error. Rolled back block number to: ${blockNumber}`);
+                }
+                util_1.metric.putMetric(`${this.protocol}SubgraphProvider.chain_${this.chainId}.getPools.timeout`, 1);
+                pools = [];
+                util_1.log.info({ err }, `Failed to get pools from subgraph. Retry attempt: ${retry}`);
+            },
+        });
+        util_1.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);
+        util_1.metric.putMetric(`${this.protocol}SubgraphProvider.chain_${this.chainId}.getPools.untracked.length`, untrackedPools.length);
+        util_1.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);
+        });
+        util_1.metric.putMetric(`${this.protocol}SubgraphProvider.chain_${this.chainId}.getPools.filter.latency`, Date.now() - beforeFilter);
+        util_1.metric.putMetric(`${this.protocol}SubgraphProvider.chain_${this.chainId}.getPools.filter.length`, poolsSanitized.length);
+        util_1.metric.putMetric(`${this.protocol}SubgraphProvider.chain_${this.chainId}.getPools.filter.percent`, (poolsSanitized.length / pools.length) * 100);
+        util_1.metric.putMetric(`${this.protocol}SubgraphProvider.chain_${this.chainId}.getPools`, 1);
+        util_1.metric.putMetric(`${this.protocol}SubgraphProvider.chain_${this.chainId}.getPools.latency`, Date.now() - beforeAll);
+        util_1.log.info(`Got ${pools.length} ${this.protocol} pools from the subgraph. ${poolsSanitized.length} after filtering`);
+        return poolsSanitized;
+    }
+}
+exports.SubgraphProvider = SubgraphProvider;
+//# sourceMappingURL=data:application/json;base64,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

package/build/main/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/main/providers/swap-router-provider.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwapRouterProvider = void 0;
+const SwapRouter02__factory_1 = require("../types/other/factories/SwapRouter02__factory");
+const util_1 = require("../util");
+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: (0, util_1.SWAP_ROUTER_02_ADDRESSES)(this.chainId),
+            contractInterface: SwapRouter02__factory_1.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)) {
+            util_1.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],
+        };
+    }
+}
+exports.SwapRouterProvider = SwapRouterProvider;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3dhcC1yb3V0ZXItcHJvdmlkZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvcHJvdmlkZXJzL3N3YXAtcm91dGVyLXByb3ZpZGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUdBLDBGQUF1RjtBQUN2RixrQ0FBd0Q7QUE2QnhELE1BQWEsa0JBQWtCO0lBQzdCLFlBQ1ksa0JBQXNDLEVBQ3RDLE9BQWdCO1FBRGhCLHVCQUFrQixHQUFsQixrQkFBa0IsQ0FBb0I7UUFDdEMsWUFBTyxHQUFQLE9BQU8sQ0FBUztJQUN6QixDQUFDO0lBRUcsS0FBSyxDQUFDLGVBQWUsQ0FDMUIsYUFBdUMsRUFDdkMsY0FBd0M7O1FBRXhDLE1BQU0sY0FBYyxHQUF1QjtZQUN6QztnQkFDRSxhQUFhLENBQUMsUUFBUSxDQUFDLE9BQU8sQ0FBQyxPQUFPO2dCQUN0QyxhQUFhLENBQUMsUUFBUSxDQUFDLFFBQVEsRUFBRTthQUNsQztZQUNEO2dCQUNFLGNBQWMsQ0FBQyxRQUFRLENBQUMsT0FBTyxDQUFDLE9BQU87Z0JBQ3ZDLGNBQWMsQ0FBQyxRQUFRLENBQUMsUUFBUSxFQUFFO2FBQ25DO1NBQ0YsQ0FBQztRQUVGLE1BQU0sRUFBRSxHQUNOLE1BQU0sSUFBSSxDQUFDLGtCQUFrQixDQUFDLDRDQUE0QyxDQUd4RTtZQUNBLE9BQU8sRUFBRSxJQUFBLCtCQUF3QixFQUFDLElBQUksQ0FBQyxPQUFPLENBQUM7WUFDL0MsaUJBQWlCLEVBQUUsNkNBQXFCLENBQUMsZUFBZSxFQUFFO1lBQzFELFlBQVksRUFBRSxpQkFBaUI7WUFDL0IsY0FBYztTQUNmLENBQUMsQ0FBQztRQUVMLElBQUksQ0FBQyxDQUFBLE1BQUEsRUFBRSxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsMENBQUUsT0FBTyxDQUFBLElBQUksQ0FBQyxDQUFBLE1BQUEsRUFBRSxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsMENBQUUsT0FBTyxDQUFBLEVBQUU7WUFDdEQsVUFBRyxDQUFDLElBQUksQ0FDTixFQUFFLE9BQU8sRUFBRSxFQUFFLENBQUMsT0FBTyxFQUFFLEVBQ3ZCLHdFQUF3RSxDQUN6RSxDQUFDO1lBQ0YsTUFBTSxJQUFJLEtBQUssQ0FDYix3RUFBd0UsQ0FDekUsQ0FBQztTQUNIO1FBRUQsTUFBTSxFQUFFLE1BQU0sRUFBRSxlQUFlLEVBQUUsR0FBRyxFQUFFLENBQUMsT0FBUSxDQUFDLENBQUMsQ0FBQyxDQUFDO1FBQ25ELE1BQU0sRUFBRSxNQUFNLEVBQUUsZ0JBQWdCLEVBQUUsR0FBRyxFQUFFLENBQUMsT0FBUSxDQUFDLENBQUMsQ0FBQyxDQUFDO1FBRXBELE9BQU87WUFDTCxlQUFlLEVBQUUsZUFBZSxDQUFDLENBQUMsQ0FBQztZQUNuQyxnQkFBZ0IsRUFBRSxnQkFBZ0IsQ0FBQyxDQUFDLENBQUM7U0FDdEMsQ0FBQztJQUNKLENBQUM7Q0FDRjtBQWxERCxnREFrREMifQ==

package/build/main/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/main/providers/token-fee-fetcher.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OnChainTokenFeeFetcher = exports.DEFAULT_TOKEN_FEE_RESULT = void 0;
+const bignumber_1 = require("@ethersproject/bignumber");
+const sdk_core_1 = require("@fanx-protocol/sdk-core");
+const TokenFeeDetector__factory_1 = require("../types/other/factories/TokenFeeDetector__factory");
+const util_1 = require("../util");
+const DEFAULT_TOKEN_BUY_FEE_BPS = bignumber_1.BigNumber.from(0);
+const DEFAULT_TOKEN_SELL_FEE_BPS = bignumber_1.BigNumber.from(0);
+// on detector failure, assume no fee
+exports.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 sdk_core_1.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;
+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 = util_1.WRAPPED_NATIVE_CURRENCY[this.chainId]) === null || _a === void 0 ? void 0 : _a.address;
+        this.contract = TokenFeeDetector__factory_1.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,
+                });
+                util_1.metric.putMetric('TokenFeeFetcherFetchFeesSuccess', 1, util_1.MetricLoggerUnit.Count);
+                return Object.assign({ address }, feeResult);
+            }
+            catch (err) {
+                util_1.log.error({ err }, `Error calling validate on-chain for token ${address}`);
+                util_1.metric.putMetric('TokenFeeFetcherFetchFeesFailure', 1, util_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;
+    }
+}
+exports.OnChainTokenFeeFetcher = OnChainTokenFeeFetcher;
+//# sourceMappingURL=data:application/json;base64,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

package/build/main/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/main/providers/token-properties-provider.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenPropertiesProvider = exports.NEGATIVE_CACHE_ENTRY_TTL = exports.POSITIVE_CACHE_ENTRY_TTL = exports.DEFAULT_TOKEN_PROPERTIES_RESULT = void 0;
+const util_1 = require("../util");
+const token_fee_fetcher_1 = require("./token-fee-fetcher");
+const token_validator_provider_1 = require("./token-validator-provider");
+exports.DEFAULT_TOKEN_PROPERTIES_RESULT = {
+    tokenFeeResult: token_fee_fetcher_1.DEFAULT_TOKEN_FEE_RESULT,
+};
+exports.POSITIVE_CACHE_ENTRY_TTL = 1200; // 20 minutes in seconds
+exports.NEGATIVE_CACHE_ENTRY_TTL = 1200; // 20 minutes in seconds
+class TokenPropertiesProvider {
+    constructor(chainId, tokenPropertiesCache, tokenFeeFetcher, allowList = token_validator_provider_1.DEFAULT_ALLOWLIST, positiveCacheEntryTTL = exports.POSITIVE_CACHE_ENTRY_TTL, negativeCacheEntryTTL = exports.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) {
+                util_1.metric.putMetric('TokenPropertiesProviderBatchGetCacheHit', 1, util_1.MetricLoggerUnit.Count);
+                const tokenFee = cachedValue.tokenFeeResult;
+                const tokenFeeResultExists = tokenFee && (tokenFee.buyFeeBps || tokenFee.sellFeeBps);
+                if (tokenFeeResultExists) {
+                    util_1.metric.putMetric(`TokenPropertiesProviderCacheHitTokenFeeResultExists${tokenFeeResultExists}`, 1, util_1.MetricLoggerUnit.Count);
+                }
+                else {
+                    util_1.metric.putMetric(`TokenPropertiesProviderCacheHitTokenFeeResultNotExists`, 1, util_1.MetricLoggerUnit.Count);
+                }
+                tokenToResult[address] = cachedValue;
+            }
+            else if (this.allowList.has(address)) {
+                tokenToResult[address] = {
+                    tokenValidationResult: token_validator_provider_1.TokenValidationResult.UNKN,
+                };
+            }
+            else {
+                addressesToFetchFeesOnchain.push(address);
+            }
+        }
+        if (addressesToFetchFeesOnchain.length > 0) {
+            let tokenFeeMap = {};
+            try {
+                tokenFeeMap = await this.tokenFeeFetcher.fetchFees(addressesToFetchFeesOnchain, providerConfig);
+            }
+            catch (err) {
+                util_1.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.
+                    util_1.metric.putMetric(`TokenPropertiesProviderTokenFeeResultCacheMissExists${tokenFeeResultExists}`, 1, util_1.MetricLoggerUnit.Count);
+                    const tokenPropertiesResult = {
+                        tokenFeeResult: tokenFee,
+                        tokenValidationResult: token_validator_provider_1.TokenValidationResult.FOT,
+                    };
+                    tokenToResult[address] = tokenPropertiesResult;
+                    util_1.metric.putMetric('TokenPropertiesProviderBatchGetCacheMiss', 1, util_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 {
+                    util_1.metric.putMetric(`TokenPropertiesProviderTokenFeeResultCacheMissNotExists`, 1, util_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 = (0, util_1.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, (0, util_1.getAddressLowerCase)(currency));
+            if (!addressesCacheKeys.has(addressCacheKey)) {
+                addressesCacheKeys.add(addressCacheKey);
+            }
+        }
+        return addressesCacheKeys;
+    }
+}
+exports.TokenPropertiesProvider = TokenPropertiesProvider;
+//# sourceMappingURL=data:application/json;base64,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

package/build/main/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;