Feature: V2 routes quote with fee-on-transfer fees off the quote amount

cli/base-command.ts

@@ -39,14 +39,17 @@ import {
   setGlobalMetric,
   SimulationStatus,
   TenderlySimulator,
+  TokenPropertiesProvider,
   TokenProvider,
+  TokenValidatorProvider,
   UniswapMulticallProvider,
   V2PoolProvider,
   V3PoolProvider,
   V3RouteWithValidQuote,
 } from '../src';
 import { LegacyGasPriceProvider } from '../src/providers/legacy-gas-price-provider';
 import { OnChainGasPriceProvider } from '../src/providers/on-chain-gas-price-provider';
+import { OnChainTokenFeeFetcher } from '../src/providers/token-fee-fetcher';
 
 export abstract class BaseCommand extends Command {
   static flags = {
@@ -284,7 +287,22 @@ export abstract class BaseCommand extends Command {
         new V3PoolProvider(chainId, multicall2Provider),
         new NodeJSCache(new NodeCache({ stdTTL: 360, useClones: false }))
       );
-      const v2PoolProvider = new V2PoolProvider(chainId, multicall2Provider);
+      const tokenValidatorProvider = new TokenValidatorProvider(
+        chainId,
+        multicall2Provider,
+        new NodeJSCache(new NodeCache({ stdTTL: 360, useClones: false }))
+      )
+      const tokenFeeFetcher = new OnChainTokenFeeFetcher(
+        chainId,
+        provider
+      )
+      const tokenPropertiesProvider = new TokenPropertiesProvider(
+        chainId,
+        tokenValidatorProvider,
+        new NodeJSCache(new NodeCache({ stdTTL: 360, useClones: false })),
+        tokenFeeFetcher
+      )
+      const v2PoolProvider = new V2PoolProvider(chainId, multicall2Provider, tokenPropertiesProvider);
 
       const tenderlySimulator = new TenderlySimulator(
         chainId,

cli/commands/quote.ts

@@ -34,6 +34,8 @@ export class Quote extends BaseCommand {
       default: false,
     }),
     simulate: flags.boolean({ required: false, default: false }),
+    debugRouting: flags.boolean({ required: false, default: true }),
+    enableFeeOnTransferFeeFetching: flags.boolean({ required: false, default: true }),
   };
 
   async run() {
@@ -63,6 +65,8 @@ export class Quote extends BaseCommand {
       forceCrossProtocol,
       forceMixedRoutes,
       simulate,
+      debugRouting,
+      enableFeeOnTransferFeeFetching
     } = flags;
 
     const topNSecondHopForTokenAddress = new MapWithLowerCaseKey();
@@ -151,6 +155,8 @@ export class Quote extends BaseCommand {
           protocols,
           forceCrossProtocol,
           forceMixedRoutes,
+          debugRouting,
+          enableFeeOnTransferFeeFetching,
         }
       );
     } else {
@@ -186,6 +192,8 @@ export class Quote extends BaseCommand {
           protocols,
           forceCrossProtocol,
           forceMixedRoutes,
+          debugRouting,
+          enableFeeOnTransferFeeFetching,
         }
       );
     }

package.json

@@ -38,9 +38,9 @@
     "@uniswap/token-lists": "^1.0.0-beta.31",
     "@uniswap/universal-router": "^1.0.1",
     "@uniswap/universal-router-sdk": "^1.5.7",
-    "@uniswap/v2-sdk": "^3.2.0",
+    "@uniswap/v2-sdk": "^3.2.1",
     "@uniswap/v3-sdk": "^3.10.0",
-    "@uniswap/sdk-core": "^4.0.6",
+    "@uniswap/sdk-core": "^4.0.7",
     "async-retry": "^1.3.1",
     "await-timeout": "^1.1.1",
     "axios": "^0.21.1",

src/providers/provider.ts

@@ -13,6 +13,10 @@ export type ProviderConfig = {
    * Debug flag to test some codepaths
    */
   debugRouting?: boolean;
+  /**
+   * Flag for token properties provider to enable fetching fee-on-transfer tokens.
+   */
+  enableFeeOnTransferFeeFetching?: boolean;
 };
 
 export type LocalCacheEntry<T> = {

src/providers/token-fee-fetcher.ts

@@ -36,8 +36,9 @@ const FEE_DETECTOR_ADDRESS = (chainId: ChainId) => {
 
 // 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
-// 10000 is the smallest number that avoids rounding errors in bps terms
-const AMOUNT_TO_FLASH_BORROW = '10000';
+// 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 = 1_000_000;
 

src/providers/token-properties-provider.ts

@@ -42,13 +42,19 @@ export class TokenPropertiesProvider implements ITokenPropertiesProvider {
     private tokenValidatorProvider: ITokenValidatorProvider,
     private tokenPropertiesCache: ICache<TokenPropertiesResult>,
     private tokenFeeFetcher: ITokenFeeFetcher,
-    private allowList = DEFAULT_ALLOWLIST
+    private allowList = DEFAULT_ALLOWLIST,
   ) {}
 
   public async getTokensProperties(
     tokens: Token[],
     providerConfig?: ProviderConfig
   ): Promise<TokenPropertiesMap> {
+    const tokenToResult: TokenPropertiesMap = {};
+
+    if (!providerConfig?.enableFeeOnTransferFeeFetching || this.chainId !== ChainId.MAINNET) {
+      return tokenToResult;
+    }
+
     const nonAllowlistTokens = tokens.filter(
       (token) => !this.allowList.has(token.address.toLowerCase())
     );
@@ -57,7 +63,6 @@ export class TokenPropertiesProvider implements ITokenPropertiesProvider {
         nonAllowlistTokens,
         providerConfig
       );
-    const tokenToResult: TokenPropertiesMap = {};
 
     tokens.forEach((token) => {
       if (this.allowList.has(token.address.toLowerCase())) {

src/providers/v2/pool-provider.ts

@@ -5,11 +5,20 @@ import retry, { Options as RetryOptions } from 'async-retry';
 import _ from 'lodash';
 
 import { IUniswapV2Pair__factory } from '../../types/v2/factories/IUniswapV2Pair__factory';
-import { CurrencyAmount, ID_TO_NETWORK_NAME, metric, MetricLoggerUnit } from '../../util';
+import {
+  CurrencyAmount,
+  ID_TO_NETWORK_NAME,
+  metric,
+  MetricLoggerUnit,
+} from '../../util';
 import { log } from '../../util/log';
 import { poolToString } from '../../util/routes';
 import { IMulticallProvider, Result } from '../multicall-provider';
 import { ProviderConfig } from '../provider';
+import {
+  ITokenPropertiesProvider,
+} from '../token-properties-provider';
+import { TokenValidationResult } from '../token-validator-provider';
 
 type IReserves = {
   reserve0: BigNumber;
@@ -66,18 +75,19 @@ export class V2PoolProvider implements IV2PoolProvider {
    * Creates an instance of V2PoolProvider.
    * @param chainId The chain id to use.
    * @param multicall2Provider The multicall provider to use to get the pools.
+   * @param tokenPropertiesProvider The token properties provider to use to get token properties.
    * @param retryOptions The retry options for each call to the multicall.
    */
   constructor(
     protected chainId: ChainId,
     protected multicall2Provider: IMulticallProvider,
+    protected tokenPropertiesProvider: ITokenPropertiesProvider,
     protected retryOptions: V2PoolRetryOptions = {
       retries: 2,
       minTimeout: 50,
       maxTimeout: 500,
     }
-  ) {
-  }
+  ) {}
 
   public async getPools(
     tokenPairs: [Token, Token][],
@@ -109,18 +119,28 @@ export class V2PoolProvider implements IV2PoolProvider {
     );
 
     metric.putMetric('V2_RPC_POOL_RPC_CALL', 1, MetricLoggerUnit.None);
-    metric.putMetric('V2GetReservesBatchSize', sortedPoolAddresses.length, MetricLoggerUnit.Count);
+    metric.putMetric(
+      'V2GetReservesBatchSize',
+      sortedPoolAddresses.length,
+      MetricLoggerUnit.Count
+    );
     metric.putMetric(
       `V2GetReservesBatchSize_${ID_TO_NETWORK_NAME(this.chainId)}`,
       sortedPoolAddresses.length,
       MetricLoggerUnit.Count
     );
 
-    const reservesResults = await this.getPoolsData<IReserves>(
-      sortedPoolAddresses,
-      'getReserves',
-      providerConfig
-    );
+    const [reservesResults, tokenPropertiesMap] = await Promise.all([
+      this.getPoolsData<IReserves>(
+        sortedPoolAddresses,
+        'getReserves',
+        providerConfig
+      ),
+      this.tokenPropertiesProvider.getTokensProperties(
+        this.flatten(tokenPairs),
+        providerConfig
+      ),
+    ]);
 
     log.info(
       `Got reserves for ${poolAddressSet.size} pools ${
@@ -144,7 +164,39 @@ export class V2PoolProvider implements IV2PoolProvider {
         continue;
       }
 
-      const [token0, token1] = sortedTokenPairs[i]!;
+      let [token0, token1] = sortedTokenPairs[i]!;
+      if (
+        tokenPropertiesMap[token0.address.toLowerCase()]
+          ?.tokenValidationResult === TokenValidationResult.FOT
+      ) {
+        token0 = new Token(
+          token0.chainId,
+          token0.address,
+          token0.decimals,
+          token0.symbol,
+          token0.name,
+          true, // at this point we know it's valid token address
+          tokenPropertiesMap[token0.address.toLowerCase()]?.tokenFeeResult?.buyFeeBps,
+          tokenPropertiesMap[token0.address.toLowerCase()]?.tokenFeeResult?.sellFeeBps
+        );
+      }
+
+      if (
+        tokenPropertiesMap[token1.address.toLowerCase()]
+          ?.tokenValidationResult === TokenValidationResult.FOT
+      ) {
+        token1 = new Token(
+          token1.chainId,
+          token1.address,
+          token1.decimals,
+          token1.symbol,
+          token1.name,
+          true, // at this point we know it's valid token address
+          tokenPropertiesMap[token1.address.toLowerCase()]?.tokenFeeResult?.buyFeeBps,
+          tokenPropertiesMap[token1.address.toLowerCase()]?.tokenFeeResult?.sellFeeBps
+        );
+      }
+
       const { reserve0, reserve1 } = reservesResult.result;
 
       const pool = new Pair(
@@ -228,4 +280,16 @@ export class V2PoolProvider implements IV2PoolProvider {
 
     return results;
   }
+
+  // We are using ES2017. ES2019 has native flatMap support
+  private flatten(tokenPairs: Array<[Token, Token]>): Token[] {
+    const tokens = new Array<Token>();
+
+    for (const [tokenA, tokenB] of tokenPairs) {
+      tokens.push(tokenA);
+      tokens.push(tokenB);
+    }
+
+    return tokens;
+  }
 }