@kumbaya_xyz/smart-order-router 4.22.38

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

@@ -0,0 +1,161 @@
+import { BigNumber } from '@ethersproject/bignumber';
+import { ChainId } from '@uniswap/sdk-core';
+import { TokenFeeDetector__factory } from '../types/other/factories/TokenFeeDetector__factory';
+import { log, metric, MetricLoggerUnit, WRAPPED_NATIVE_CURRENCY, } from '../util';
+import { USDC_ON, USDT_ON } from './token-provider';
+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.WORLDCHAIN:
+            return '0xbc708B192552e19A088b4C4B8772aEeA83bCf760';
+        case ChainId.UNICHAIN_SEPOLIA:
+            return '0xbc708B192552e19A088b4C4B8772aEeA83bCf760';
+        case ChainId.UNICHAIN:
+            return '0xbc708B192552e19A088b4C4B8772aEeA83bCf760';
+        case ChainId.SONEIUM:
+            return '0x7A5299822b2cD9aC9A9f67756Aa2d62140e9A66f';
+        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) {
+        this.tokenFeeAddress = tokenFeeAddress;
+        this.gasLimitPerCall = gasLimitPerCall;
+        this.amountToFlashBorrow = amountToFlashBorrow;
+        this.BASE_TOKENS = this.getBaseTokensByChain(chainId);
+        this.contract = TokenFeeDetector__factory.connect(this.tokenFeeAddress, rpcProvider);
+    }
+    getBaseTokensByChain(chainId) {
+        var _a, _b, _c;
+        const baseTokens = [];
+        // Priority order: WETH -> USDT -> USDC
+        const weth = (_a = WRAPPED_NATIVE_CURRENCY[chainId]) === null || _a === void 0 ? void 0 : _a.address;
+        if (weth) {
+            baseTokens.push(weth);
+        }
+        try {
+            const usdt = (_b = USDT_ON(chainId)) === null || _b === void 0 ? void 0 : _b.address;
+            if (usdt) {
+                baseTokens.push(usdt);
+            }
+        }
+        catch (e) {
+            // USDT not available on this chain
+        }
+        try {
+            const usdc = (_c = USDC_ON(chainId)) === null || _c === void 0 ? void 0 : _c.address;
+            if (usdc) {
+                baseTokens.push(usdc);
+            }
+        }
+        catch (e) {
+            // USDC not available on this chain
+        }
+        return baseTokens;
+    }
+    async fetchFees(addresses, providerConfig) {
+        const tokenToResult = {};
+        // Filter out all base tokens from the addresses to check
+        const baseTokensLower = this.BASE_TOKENS.map((addr) => addr.toLowerCase());
+        const addressesWithoutBaseTokens = addresses.filter((address) => !baseTokensLower.includes(address.toLowerCase()));
+        // Create function params for all token x base token combinations
+        const functionParams = [];
+        for (const address of addressesWithoutBaseTokens) {
+            for (const baseToken of this.BASE_TOKENS) {
+                functionParams.push([address, baseToken, this.amountToFlashBorrow]);
+            }
+        }
+        // Execute all validation calls in parallel
+        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, baseToken, ...feeResult };
+            }
+            catch (err) {
+                log.error({ err }, `Error calling validate on-chain for token ${address} with base token ${baseToken}`);
+                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,
+                    baseToken,
+                    buyFeeBps: undefined,
+                    sellFeeBps: undefined,
+                    feeTakenOnTransfer: false,
+                    externalTransferFailed: false,
+                    sellReverted: false,
+                };
+            }
+        }));
+        // Group results by token address and pick the first successful result
+        // (prioritizing by base token order: WETH -> USDT -> USDC)
+        const resultsByToken = new Map();
+        for (const result of results) {
+            const existing = resultsByToken.get(result.address) || [];
+            existing.push(result);
+            resultsByToken.set(result.address, existing);
+        }
+        // For each token, find the first successful result (by base token priority)
+        for (const [address, tokenResults] of resultsByToken) {
+            // Sort by base token priority order
+            const sortedResults = tokenResults.sort((a, b) => {
+                const aIndex = this.BASE_TOKENS.indexOf(a.baseToken);
+                const bIndex = this.BASE_TOKENS.indexOf(b.baseToken);
+                return aIndex - bIndex;
+            });
+            // Find first result with valid fee data (buyFeeBps or sellFeeBps > 0)
+            const validResult = sortedResults.find((result) => (result.buyFeeBps && !result.buyFeeBps.isZero()) ||
+                (result.sellFeeBps && !result.sellFeeBps.isZero()));
+            if (validResult) {
+                tokenToResult[address] = {
+                    buyFeeBps: validResult.buyFeeBps,
+                    sellFeeBps: validResult.sellFeeBps,
+                    feeTakenOnTransfer: validResult.feeTakenOnTransfer,
+                    externalTransferFailed: validResult.externalTransferFailed,
+                    sellReverted: validResult.sellReverted,
+                };
+            }
+        }
+        return tokenToResult;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9rZW4tZmVlLWZldGNoZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvcHJvdmlkZXJzL3Rva2VuLWZlZS1mZXRjaGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQUVyRCxPQUFPLEVBQUUsT0FBTyxFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFHNUMsT0FBTyxFQUFFLHlCQUF5QixFQUFFLE1BQU0sb0RBQW9ELENBQUM7QUFDL0YsT0FBTyxFQUNMLEdBQUcsRUFDSCxNQUFNLEVBQ04sZ0JBQWdCLEVBQ2hCLHVCQUF1QixHQUN4QixNQUFNLFNBQVMsQ0FBQztBQUdqQixPQUFPLEVBQUUsT0FBTyxFQUFFLE9BQU8sRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBRXBELE1BQU0seUJBQXlCLEdBQUcsU0FBUyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FBQztBQUNwRCxNQUFNLDBCQUEwQixHQUFHLFNBQVMsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLENBQUM7QUFFckQscUNBQXFDO0FBQ3JDLE1BQU0sQ0FBQyxNQUFNLHdCQUF3QixHQUFHO0lBQ3RDLFNBQVMsRUFBRSx5QkFBeUI7SUFDcEMsVUFBVSxFQUFFLDBCQUEwQjtDQUN2QyxDQUFDO0FBYUYsb0RBQW9EO0FBQ3BELE1BQU0sb0JBQW9CLEdBQUcsQ0FBQyxPQUFnQixFQUFFLEVBQUU7SUFDaEQsUUFBUSxPQUFPLEVBQUU7UUFDZixLQUFLLE9BQU8sQ0FBQyxPQUFPO1lBQ2xCLE9BQU8sNENBQTRDLENBQUM7UUFDdEQsS0FBSyxPQUFPLENBQUMsUUFBUTtZQUNuQixPQUFPLDRDQUE0QyxDQUFDO1FBQ3RELEtBQUssT0FBTyxDQUFDLEdBQUc7WUFDZCxPQUFPLDRDQUE0QyxDQUFDO1FBQ3RELEtBQUssT0FBTyxDQUFDLE9BQU87WUFDbEIsT0FBTyw0Q0FBNEMsQ0FBQztRQUN0RCxLQUFLLE9BQU8sQ0FBQyxJQUFJO1lBQ2YsT0FBTyw0Q0FBNEMsQ0FBQztRQUN0RCxLQUFLLE9BQU8sQ0FBQyxZQUFZO1lBQ3ZCLE9BQU8sNENBQTRDLENBQUM7UUFDdEQsS0FBSyxPQUFPLENBQUMsSUFBSTtZQUNmLE9BQU8sNENBQTRDLENBQUM7UUFDdEQsS0FBSyxPQUFPLENBQUMsU0FBUztZQUNwQixPQUFPLDRDQUE0QyxDQUFDO1FBQ3RELEtBQUssT0FBTyxDQUFDLFVBQVU7WUFDckIsT0FBTyw0Q0FBNEMsQ0FBQztRQUN0RCxLQUFLLE9BQU8sQ0FBQyxnQkFBZ0I7WUFDM0IsT0FBTyw0Q0FBNEMsQ0FBQztRQUN0RCxLQUFLLE9BQU8sQ0FBQyxRQUFRO1lBQ25CLE9BQU8sNENBQTRDLENBQUM7UUFDdEQsS0FBSyxPQUFPLENBQUMsT0FBTztZQUNsQixPQUFPLDRDQUE0QyxDQUFDO1FBQ3REO1lBQ0UsbUNBQW1DO1lBQ25DLE9BQU8sNENBQTRDLENBQUM7S0FDdkQ7QUFDSCxDQUFDLENBQUM7QUFFRiw4RUFBOEU7QUFDOUUseURBQXlEO0FBQ3pELHlFQUF5RTtBQUN6RSxnRkFBZ0Y7QUFDaEYsTUFBTSxzQkFBc0IsR0FBRyxRQUFRLENBQUM7QUFDeEMsK0RBQStEO0FBQy9ELE1BQU0sc0JBQXNCLEdBQUcsT0FBUyxDQUFDO0FBU3pDLE1BQU0sT0FBTyxzQkFBc0I7SUFJakMsWUFDRSxPQUFnQixFQUNoQixXQUF5QixFQUNqQixrQkFBa0Isb0JBQW9CLENBQUMsT0FBTyxDQUFDLEVBQy9DLGtCQUFrQixzQkFBc0IsRUFDeEMsc0JBQXNCLHNCQUFzQjtRQUY1QyxvQkFBZSxHQUFmLGVBQWUsQ0FBZ0M7UUFDL0Msb0JBQWUsR0FBZixlQUFlLENBQXlCO1FBQ3hDLHdCQUFtQixHQUFuQixtQkFBbUIsQ0FBeUI7UUFFcEQsSUFBSSxDQUFDLFdBQVcsR0FBRyxJQUFJLENBQUMsb0JBQW9CLENBQUMsT0FBTyxDQUFDLENBQUM7UUFDdEQsSUFBSSxDQUFDLFFBQVEsR0FBRyx5QkFBeUIsQ0FBQyxPQUFPLENBQy9DLElBQUksQ0FBQyxlQUFlLEVBQ3BCLFdBQVcsQ0FDWixDQUFDO0lBQ0osQ0FBQztJQUVPLG9CQUFvQixDQUFDLE9BQWdCOztRQUMzQyxNQUFNLFVBQVUsR0FBYSxFQUFFLENBQUM7UUFFaEMsdUNBQXVDO1FBQ3ZDLE1BQU0sSUFBSSxHQUFHLE1BQUEsdUJBQXVCLENBQUMsT0FBTyxDQUFDLDBDQUFFLE9BQU8sQ0FBQztRQUN2RCxJQUFJLElBQUksRUFBRTtZQUNSLFVBQVUsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUM7U0FDdkI7UUFFRCxJQUFJO1lBQ0YsTUFBTSxJQUFJLEdBQUcsTUFBQSxPQUFPLENBQUMsT0FBTyxDQUFDLDBDQUFFLE9BQU8sQ0FBQztZQUN2QyxJQUFJLElBQUksRUFBRTtnQkFDUixVQUFVLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDO2FBQ3ZCO1NBQ0Y7UUFBQyxPQUFPLENBQUMsRUFBRTtZQUNWLG1DQUFtQztTQUNwQztRQUVELElBQUk7WUFDRixNQUFNLElBQUksR0FBRyxNQUFBLE9BQU8sQ0FBQyxPQUFPLENBQUMsMENBQUUsT0FBTyxDQUFDO1lBQ3ZDLElBQUksSUFBSSxFQUFFO2dCQUNSLFVBQVUsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUM7YUFDdkI7U0FDRjtRQUFDLE9BQU8sQ0FBQyxFQUFFO1lBQ1YsbUNBQW1DO1NBQ3BDO1FBRUQsT0FBTyxVQUFVLENBQUM7SUFDcEIsQ0FBQztJQUVNLEtBQUssQ0FBQyxTQUFTLENBQ3BCLFNBQW9CLEVBQ3BCLGNBQStCO1FBRS9CLE1BQU0sYUFBYSxHQUFnQixFQUFFLENBQUM7UUFFdEMseURBQXlEO1FBQ3pELE1BQU0sZUFBZSxHQUFHLElBQUksQ0FBQyxXQUFXLENBQUMsR0FBRyxDQUFDLENBQUMsSUFBSSxFQUFFLEVBQUUsQ0FBQyxJQUFJLENBQUMsV0FBVyxFQUFFLENBQUMsQ0FBQztRQUMzRSxNQUFNLDBCQUEwQixHQUFHLFNBQVMsQ0FBQyxNQUFNLENBQ2pELENBQUMsT0FBTyxFQUFFLEVBQUUsQ0FBQyxDQUFDLGVBQWUsQ0FBQyxRQUFRLENBQUMsT0FBTyxDQUFDLFdBQVcsRUFBRSxDQUFDLENBQzlELENBQUM7UUFFRixpRUFBaUU7UUFDakUsTUFBTSxjQUFjLEdBQStCLEVBQUUsQ0FBQztRQUN0RCxLQUFLLE1BQU0sT0FBTyxJQUFJLDBCQUEwQixFQUFFO1lBQ2hELEtBQUssTUFBTSxTQUFTLElBQUksSUFBSSxDQUFDLFdBQVcsRUFBRTtnQkFDeEMsY0FBYyxDQUFDLElBQUksQ0FBQyxDQUFDLE9BQU8sRUFBRSxTQUFTLEVBQUUsSUFBSSxDQUFDLG1CQUFtQixDQUFDLENBQUMsQ0FBQzthQUNyRTtTQUNGO1FBRUQsMkNBQTJDO1FBQzNDLE1BQU0sT0FBTyxHQUFHLE1BQU0sT0FBTyxDQUFDLEdBQUcsQ0FDL0IsY0FBYyxDQUFDLEdBQUcsQ0FBQyxLQUFLLEVBQUUsQ0FBQyxPQUFPLEVBQUUsU0FBUyxFQUFFLGNBQWMsQ0FBQyxFQUFFLEVBQUU7WUFDaEUsSUFBSTtnQkFDRixzRkFBc0Y7Z0JBQ3RGLDZFQUE2RTtnQkFDN0UsTUFBTSxTQUFTLEdBQUcsTUFBTSxJQUFJLENBQUMsUUFBUSxDQUFDLFVBQVUsQ0FBQyxRQUFRLENBQ3ZELE9BQU8sRUFDUCxTQUFTLEVBQ1QsY0FBYyxFQUNkO29CQUNFLFFBQVEsRUFBRSxJQUFJLENBQUMsZUFBZTtvQkFDOUIsUUFBUSxFQUFFLGNBQWMsYUFBZCxjQUFjLHVCQUFkLGNBQWMsQ0FBRSxXQUFXO2lCQUN0QyxDQUNGLENBQUM7Z0JBRUYsTUFBTSxDQUFDLFNBQVMsQ0FDZCxpQ0FBaUMsRUFDakMsQ0FBQyxFQUNELGdCQUFnQixDQUFDLEtBQUssQ0FDdkIsQ0FBQztnQkFFRixPQUFPLEVBQUUsT0FBTyxFQUFFLFNBQVMsRUFBRSxHQUFHLFNBQVMsRUFBRSxDQUFDO2FBQzdDO1lBQUMsT0FBTyxHQUFHLEVBQUU7Z0JBQ1osR0FBRyxDQUFDLEtBQUssQ0FDUCxFQUFFLEdBQUcsRUFBRSxFQUNQLDZDQUE2QyxPQUFPLG9CQUFvQixTQUFTLEVBQUUsQ0FDcEYsQ0FBQztnQkFFRixNQUFNLENBQUMsU0FBUyxDQUNkLGlDQUFpQyxFQUNqQyxDQUFDLEVBQ0QsZ0JBQWdCLENBQUMsS0FBSyxDQUN2QixDQUFDO2dCQUVGLHlEQUF5RDtnQkFDekQsNkRBQTZEO2dCQUM3RCxvR0FBb0c7Z0JBQ3BHLE9BQU87b0JBQ0wsT0FBTztvQkFDUCxTQUFTO29CQUNULFNBQVMsRUFBRSxTQUFTO29CQUNwQixVQUFVLEVBQUUsU0FBUztvQkFDckIsa0JBQWtCLEVBQUUsS0FBSztvQkFDekIsc0JBQXNCLEVBQUUsS0FBSztvQkFDN0IsWUFBWSxFQUFFLEtBQUs7aUJBQ3BCLENBQUM7YUFDSDtRQUNILENBQUMsQ0FBQyxDQUNILENBQUM7UUFFRixzRUFBc0U7UUFDdEUsMkRBQTJEO1FBQzNELE1BQU0sY0FBYyxHQUFHLElBQUksR0FBRyxFQUEwQixDQUFDO1FBQ3pELEtBQUssTUFBTSxNQUFNLElBQUksT0FBTyxFQUFFO1lBQzVCLE1BQU0sUUFBUSxHQUFHLGNBQWMsQ0FBQyxHQUFHLENBQUMsTUFBTSxDQUFDLE9BQU8sQ0FBQyxJQUFJLEVBQUUsQ0FBQztZQUMxRCxRQUFRLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFDO1lBQ3RCLGNBQWMsQ0FBQyxHQUFHLENBQUMsTUFBTSxDQUFDLE9BQU8sRUFBRSxRQUFRLENBQUMsQ0FBQztTQUM5QztRQUVELDRFQUE0RTtRQUM1RSxLQUFLLE1BQU0sQ0FBQyxPQUFPLEVBQUUsWUFBWSxDQUFDLElBQUksY0FBYyxFQUFFO1lBQ3BELG9DQUFvQztZQUNwQyxNQUFNLGFBQWEsR0FBRyxZQUFZLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsRUFBRSxFQUFFO2dCQUMvQyxNQUFNLE1BQU0sR0FBRyxJQUFJLENBQUMsV0FBVyxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsU0FBUyxDQUFDLENBQUM7Z0JBQ3JELE1BQU0sTUFBTSxHQUFHLElBQUksQ0FBQyxXQUFXLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQyxTQUFTLENBQUMsQ0FBQztnQkFDckQsT0FBTyxNQUFNLEdBQUcsTUFBTSxDQUFDO1lBQ3pCLENBQUMsQ0FBQyxDQUFDO1lBR0gsc0VBQXNFO1lBQ3RFLE1BQU0sV0FBVyxHQUFHLGFBQWEsQ0FBQyxJQUFJLENBQ3BDLENBQUMsTUFBTSxFQUFFLEVBQUUsQ0FDVCxDQUFDLE1BQU0sQ0FBQyxTQUFTLElBQUksQ0FBQyxNQUFNLENBQUMsU0FBUyxDQUFDLE1BQU0sRUFBRSxDQUFDO2dCQUNoRCxDQUFDLE1BQU0sQ0FBQyxVQUFVLElBQUksQ0FBQyxNQUFNLENBQUMsVUFBVSxDQUFDLE1BQU0sRUFBRSxDQUFDLENBQ3JELENBQUM7WUFFRixJQUFJLFdBQVcsRUFBRTtnQkFDZixhQUFhLENBQUMsT0FBTyxDQUFDLEdBQUc7b0JBQ3ZCLFNBQVMsRUFBRSxXQUFXLENBQUMsU0FBUztvQkFDaEMsVUFBVSxFQUFFLFdBQVcsQ0FBQyxVQUFVO29CQUNsQyxrQkFBa0IsRUFBRSxXQUFXLENBQUMsa0JBQWtCO29CQUNsRCxzQkFBc0IsRUFBRSxXQUFXLENBQUMsc0JBQXNCO29CQUMxRCxZQUFZLEVBQUUsV0FBVyxDQUFDLFlBQVk7aUJBQ3ZDLENBQUM7YUFDSDtTQUNGO1FBRUQsT0FBTyxhQUFhLENBQUM7SUFDdkIsQ0FBQztDQUNGIn0=

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

@@ -0,0 +1,31 @@
+import { ChainId, Currency } from '@uniswap/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;
+type Address = string;
+export type TokenPropertiesResult = {
+    tokenFeeResult?: TokenFeeResult;
+    tokenValidationResult?: TokenValidationResult;
+};
+export 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,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

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

@@ -0,0 +1,141 @@
+import { ChainId, Token } from '@uniswap/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 type TokenAccessor = {
+    getTokenByAddress(address: string): Token | undefined;
+    getTokenBySymbol(symbol: string): Token | undefined;
+    getAllTokens: () => Token[];
+};
+export declare const USDC_MAINNET: Token;
+export declare const USDT_MAINNET: Token;
+export declare const WBTC_MAINNET: Token;
+export declare const DAI_MAINNET: Token;
+export declare const EGGS_MAINNET: Token;
+export declare const AMPL_MAINNET: Token;
+export declare const FEI_MAINNET: Token;
+export declare const UNI_MAINNET: Token;
+export declare const AAVE_MAINNET: Token;
+export declare const LIDO_MAINNET: Token;
+export declare const WSTETH_MAINNET: Token;
+export declare const USDC_SEPOLIA: Token;
+export declare const USDC_NATIVE_SEPOLIA: Token;
+export declare const DAI_SEPOLIA: Token;
+export declare const USDC_GOERLI: Token;
+export declare const USDT_GOERLI: Token;
+export declare const WBTC_GOERLI: Token;
+export declare const DAI_GOERLI: Token;
+export declare const UNI_GOERLI: Token;
+export declare const USDC_OPTIMISM: Token;
+export declare const USDC_NATIVE_OPTIMISM: Token;
+export declare const USDT_OPTIMISM: Token;
+export declare const WBTC_OPTIMISM: Token;
+export declare const DAI_OPTIMISM: Token;
+export declare const OP_OPTIMISM: Token;
+export declare const USDC_OPTIMISM_GOERLI: Token;
+export declare const USDT_OPTIMISM_GOERLI: Token;
+export declare const WBTC_OPTIMISM_GOERLI: Token;
+export declare const DAI_OPTIMISM_GOERLI: Token;
+export declare const USDC_OPTIMISM_SEPOLIA: Token;
+export declare const USDT_OPTIMISM_SEPOLIA: Token;
+export declare const WBTC_OPTIMISM_SEPOLIA: Token;
+export declare const DAI_OPTIMISM_SEPOLIA: Token;
+export declare const USDC_ARBITRUM: Token;
+export declare const USDC_NATIVE_ARBITRUM: Token;
+export declare const USDT_ARBITRUM: Token;
+export declare const WBTC_ARBITRUM: Token;
+export declare const DAI_ARBITRUM: Token;
+export declare const ARB_ARBITRUM: Token;
+export declare const DAI_ARBITRUM_GOERLI: Token;
+export declare const DAI_ARBITRUM_SEPOLIA: Token;
+export declare const USDC_ARBITRUM_GOERLI: Token;
+export declare const USDC_ARBITRUM_SEPOLIA: Token;
+export declare const WMATIC_POLYGON: Token;
+export declare const WETH_POLYGON: Token;
+export declare const USDC_POLYGON: Token;
+export declare const USDC_NATIVE_POLYGON: Token;
+export declare const DAI_POLYGON: Token;
+export declare const DAI_BASE_SEPOLIA: Token;
+export declare const WMATIC_POLYGON_MUMBAI: Token;
+export declare const USDC_POLYGON_MUMBAI: Token;
+export declare const DAI_POLYGON_MUMBAI: Token;
+export declare const WETH_POLYGON_MUMBAI: Token;
+export declare const BTC_BNB: Token;
+export declare const BUSD_BNB: Token;
+export declare const DAI_BNB: Token;
+export declare const ETH_BNB: Token;
+export declare const USDC_BNB: Token;
+export declare const USDT_BNB: Token;
+export declare const CELO: Token;
+export declare const DAI_CELO: Token;
+export declare const CUSD_CELO: Token;
+export declare const USDC_CELO: Token;
+export declare const USDC_WORMHOLE_CELO: Token;
+export declare const USDC_NATIVE_CELO: Token;
+export declare const CEUR_CELO: Token;
+export declare const CELO_ALFAJORES: Token;
+export declare const DAI_CELO_ALFAJORES: Token;
+export declare const CUSD_CELO_ALFAJORES: Token;
+export declare const CEUR_CELO_ALFAJORES: Token;
+export declare const DAI_AVAX: Token;
+export declare const USDC_AVAX: Token;
+export declare const USDC_BRIDGED_AVAX: Token;
+export declare const USDC_NATIVE_AVAX: Token;
+export declare const USDC_BASE: Token;
+export declare const USDC_NATIVE_BASE: Token;
+export declare const VIRTUAL_BASE: Token;
+export declare const USDC_BASE_GOERLI: Token;
+export declare const USDC_ETHEREUM_GNOSIS: Token;
+export declare const WXDAI_GNOSIS: Token;
+export declare const WBTC_GNOSIS: Token;
+export declare const USDC_MOONBEAM: Token;
+export declare const WGLMR_MOONBEAM: Token;
+export declare const DAI_MOONBEAM: Token;
+export declare const WBTC_MOONBEAM: Token;
+export declare const USDB_BLAST: Token;
+export declare const USDC_ZORA: Token;
+export declare const USDC_ZKSYNC: Token;
+export declare const USDCE_ZKSYNC: Token;
+export declare const DAI_ZKSYNC: Token;
+export declare const USDC_WORLDCHAIN: Token;
+export declare const USDT_MONAD_TESTNET: Token;
+export declare const USDC_MONAD: Token;
+export declare const WLD_WORLDCHAIN: Token;
+export declare const WBTC_WORLDCHAIN: Token;
+export declare const USDC_UNICHAIN_SEPOLIA: Token;
+export declare const USDC_BASE_SEPOLIA: Token;
+export declare const USDC_UNICHAIN: Token;
+export declare const DAI_UNICHAIN: Token;
+export declare const USDC_SONEIUM: Token;
+export declare const USDC_MEGAETH_TESTNET: Token;
+export declare const USDT_MEGAETH_TESTNET: Token;
+export declare const WBTC_MEGAETH_TESTNET: 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;
+export declare const V4_SEPOLIA_TEST_A: Token;
+export declare const V4_SEPOLIA_TEST_B: Token;