@ring-protocol/smart-order-router 0.5.0

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

@@ -0,0 +1,21 @@
+import { ChainId } from '@ring-protocol/sdk-core';
+import { V2SubgraphPool } from './v2/subgraph-provider';
+import { RingV2SubgraphPool } from './fewV2/ring-subgraph-provider';
+import { V3SubgraphPool } from './v3/subgraph-provider';
+/**
+ * Gets subgraph pools from a URI. The URI shoudl contain a JSON
+ * stringified array of V2SubgraphPool objects or V3SubgraphPool
+ * objects.
+ *
+ * @export
+ * @class URISubgraphProvider
+ * @template TSubgraphPool
+ */
+export declare class URISubgraphProvider<TSubgraphPool extends RingV2SubgraphPool | V2SubgraphPool | V3SubgraphPool> {
+    private chainId;
+    private uri;
+    private timeout;
+    private retries;
+    constructor(chainId: ChainId, uri: string, timeout?: number, retries?: number);
+    getPools(): Promise<TSubgraphPool[]>;
+}

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

@@ -0,0 +1,58 @@
+import retry from 'async-retry';
+import Timeout from 'await-timeout';
+import axios from 'axios';
+import { log } from '../util/log';
+/**
+ * Gets subgraph pools from a URI. The URI shoudl contain a JSON
+ * stringified array of V2SubgraphPool objects or V3SubgraphPool
+ * objects.
+ *
+ * @export
+ * @class URISubgraphProvider
+ * @template TSubgraphPool
+ */
+export class URISubgraphProvider {
+    constructor(chainId, uri, timeout = 6000, retries = 2) {
+        this.chainId = chainId;
+        this.uri = uri;
+        this.timeout = timeout;
+        this.retries = retries;
+    }
+    async getPools() {
+        log.info({ uri: this.uri }, `About to get subgraph pools from URI ${this.uri}`);
+        let allPools = [];
+        await retry(async () => {
+            const timeout = new Timeout();
+            const timerPromise = timeout.set(this.timeout).then(() => {
+                throw new Error(`Timed out getting pools from subgraph: ${this.timeout}`);
+            });
+            let response;
+            /* eslint-disable no-useless-catch */
+            try {
+                response = await Promise.race([axios.get(this.uri), timerPromise]);
+            }
+            catch (err) {
+                throw err;
+            }
+            finally {
+                timeout.clear();
+            }
+            /* eslint-enable no-useless-catch */
+            const { data: poolsBuffer, status } = response;
+            if (status != 200) {
+                log.error({ response }, `Unabled to get pools from ${this.uri}.`);
+                throw new Error(`Unable to get pools from ${this.uri}`);
+            }
+            const pools = poolsBuffer;
+            log.info({ uri: this.uri, chain: this.chainId }, `Got subgraph pools from uri. Num: ${pools.length}`);
+            allPools = pools;
+        }, {
+            retries: this.retries,
+            onRetry: (err, retry) => {
+                log.info({ err }, `Failed to get pools from uri ${this.uri}. Retry attempt: ${retry}`);
+            },
+        });
+        return allPools;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXJpLXN1YmdyYXBoLXByb3ZpZGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3Byb3ZpZGVycy91cmktc3ViZ3JhcGgtcHJvdmlkZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxLQUFLLE1BQU0sYUFBYSxDQUFDO0FBQ2hDLE9BQU8sT0FBTyxNQUFNLGVBQWUsQ0FBQztBQUNwQyxPQUFPLEtBQUssTUFBTSxPQUFPLENBQUM7QUFFMUIsT0FBTyxFQUFFLEdBQUcsRUFBRSxNQUFNLGFBQWEsQ0FBQztBQU1sQzs7Ozs7Ozs7R0FRRztBQUNILE1BQU0sT0FBTyxtQkFBbUI7SUFHOUIsWUFDVSxPQUFnQixFQUNoQixHQUFXLEVBQ1gsVUFBVSxJQUFJLEVBQ2QsVUFBVSxDQUFDO1FBSFgsWUFBTyxHQUFQLE9BQU8sQ0FBUztRQUNoQixRQUFHLEdBQUgsR0FBRyxDQUFRO1FBQ1gsWUFBTyxHQUFQLE9BQU8sQ0FBTztRQUNkLFlBQU8sR0FBUCxPQUFPLENBQUk7SUFDakIsQ0FBQztJQUVFLEtBQUssQ0FBQyxRQUFRO1FBQ25CLEdBQUcsQ0FBQyxJQUFJLENBQ04sRUFBRSxHQUFHLEVBQUUsSUFBSSxDQUFDLEdBQUcsRUFBRSxFQUNqQix3Q0FBd0MsSUFBSSxDQUFDLEdBQUcsRUFBRSxDQUNuRCxDQUFDO1FBRUYsSUFBSSxRQUFRLEdBQW9CLEVBQUUsQ0FBQztRQUVuQyxNQUFNLEtBQUssQ0FDVCxLQUFLLElBQUksRUFBRTtZQUNULE1BQU0sT0FBTyxHQUFHLElBQUksT0FBTyxFQUFFLENBQUM7WUFDOUIsTUFBTSxZQUFZLEdBQUcsT0FBTyxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLENBQUMsSUFBSSxDQUFDLEdBQUcsRUFBRTtnQkFDdkQsTUFBTSxJQUFJLEtBQUssQ0FDYiwwQ0FBMEMsSUFBSSxDQUFDLE9BQU8sRUFBRSxDQUN6RCxDQUFDO1lBQ0osQ0FBQyxDQUFDLENBQUM7WUFFSCxJQUFJLFFBQVEsQ0FBQztZQUViLHFDQUFxQztZQUNyQyxJQUFJO2dCQUNGLFFBQVEsR0FBRyxNQUFNLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsRUFBRSxZQUFZLENBQUMsQ0FBQyxDQUFDO2FBQ3BFO1lBQUMsT0FBTyxHQUFHLEVBQUU7Z0JBQ1osTUFBTSxHQUFHLENBQUM7YUFDWDtvQkFBUztnQkFDUixPQUFPLENBQUMsS0FBSyxFQUFFLENBQUM7YUFDakI7WUFDRCxvQ0FBb0M7WUFFcEMsTUFBTSxFQUFFLElBQUksRUFBRSxXQUFXLEVBQUUsTUFBTSxFQUFFLEdBQUcsUUFBUSxDQUFDO1lBRS9DLElBQUksTUFBTSxJQUFJLEdBQUcsRUFBRTtnQkFDakIsR0FBRyxDQUFDLEtBQUssQ0FBQyxFQUFFLFFBQVEsRUFBRSxFQUFFLDZCQUE2QixJQUFJLENBQUMsR0FBRyxHQUFHLENBQUMsQ0FBQztnQkFFbEUsTUFBTSxJQUFJLEtBQUssQ0FBQyw0QkFBNEIsSUFBSSxDQUFDLEdBQUcsRUFBRSxDQUFDLENBQUM7YUFDekQ7WUFFRCxNQUFNLEtBQUssR0FBRyxXQUE4QixDQUFDO1lBRTdDLEdBQUcsQ0FBQyxJQUFJLENBQ04sRUFBRSxHQUFHLEVBQUUsSUFBSSxDQUFDLEdBQUcsRUFBRSxLQUFLLEVBQUUsSUFBSSxDQUFDLE9BQU8sRUFBRSxFQUN0QyxxQ0FBcUMsS0FBSyxDQUFDLE1BQU0sRUFBRSxDQUNwRCxDQUFDO1lBRUYsUUFBUSxHQUFHLEtBQUssQ0FBQztRQUNuQixDQUFDLEVBQ0Q7WUFDRSxPQUFPLEVBQUUsSUFBSSxDQUFDLE9BQU87WUFDckIsT0FBTyxFQUFFLENBQUMsR0FBRyxFQUFFLEtBQUssRUFBRSxFQUFFO2dCQUN0QixHQUFHLENBQUMsSUFBSSxDQUNOLEVBQUUsR0FBRyxFQUFFLEVBQ1AsZ0NBQWdDLElBQUksQ0FBQyxHQUFHLG9CQUFvQixLQUFLLEVBQUUsQ0FDcEUsQ0FBQztZQUNKLENBQUM7U0FDRixDQUNGLENBQUM7UUFFRixPQUFPLFFBQVEsQ0FBQztJQUNsQixDQUFDO0NBQ0YifQ==

package/build/module/providers/v2/caching-pool-provider.d.ts

@@ -0,0 +1,33 @@
+import { ChainId, Token } from '@ring-protocol/sdk-core';
+import { Pair } from '@ring-protocol/v2-sdk';
+import { ICache } from './../cache';
+import { ProviderConfig } from './../provider';
+import { IV2PoolProvider, V2PoolAccessor } from './pool-provider';
+/**
+ * Provider for getting V2 pools, with functionality for caching the results per block.
+ *
+ * @export
+ * @class CachingV2PoolProvider
+ */
+export declare class CachingV2PoolProvider implements IV2PoolProvider {
+    protected chainId: ChainId;
+    protected poolProvider: IV2PoolProvider;
+    private cache;
+    private POOL_KEY;
+    /**
+     * Creates an instance of CachingV3PoolProvider.
+     * @param chainId The chain id to use.
+     * @param poolProvider The provider to use to get the pools when not in the cache.
+     * @param cache Cache instance to hold cached pools.
+     */
+    constructor(chainId: ChainId, poolProvider: IV2PoolProvider, cache: ICache<{
+        pair: Pair;
+        block?: number;
+    }>);
+    getPools(tokenPairs: [Token, Token][], providerConfig?: ProviderConfig): Promise<V2PoolAccessor>;
+    getPoolAddress(tokenA: Token, tokenB: Token): {
+        poolAddress: string;
+        token0: Token;
+        token1: Token;
+    };
+}

package/build/module/providers/v2/caching-pool-provider.js

@@ -0,0 +1,85 @@
+import _ from 'lodash';
+import { log } from '../../util/log';
+/**
+ * Provider for getting V2 pools, with functionality for caching the results per block.
+ *
+ * @export
+ * @class CachingV2PoolProvider
+ */
+export class CachingV2PoolProvider {
+    /**
+     * Creates an instance of CachingV3PoolProvider.
+     * @param chainId The chain id to use.
+     * @param poolProvider The provider to use to get the pools when not in the cache.
+     * @param cache Cache instance to hold cached pools.
+     */
+    constructor(chainId, poolProvider, 
+    // Cache is block aware. For V2 pools we need to use the current blocks reserves values since
+    // we compute quotes off-chain.
+    // If no block is specified in the call to getPools we just return whatever is in the cache.
+    cache) {
+        this.chainId = chainId;
+        this.poolProvider = poolProvider;
+        this.cache = cache;
+        this.POOL_KEY = (chainId, address) => `pool-${chainId}-${address}`;
+    }
+    async getPools(tokenPairs, providerConfig) {
+        const poolAddressSet = new Set();
+        const poolsToGetTokenPairs = [];
+        const poolsToGetAddresses = [];
+        const poolAddressToPool = {};
+        const blockNumber = await (providerConfig === null || providerConfig === void 0 ? void 0 : providerConfig.blockNumber);
+        for (const [tokenA, tokenB] of tokenPairs) {
+            const { poolAddress, token0, token1 } = this.getPoolAddress(tokenA, tokenB);
+            if (poolAddressSet.has(poolAddress)) {
+                continue;
+            }
+            poolAddressSet.add(poolAddress);
+            const cachedPool = await this.cache.get(this.POOL_KEY(this.chainId, poolAddress));
+            if (cachedPool) {
+                // If a block was specified by the caller, ensure that the result in our cache matches the
+                // expected block number. If a block number is not specified, just return whatever is in the
+                // cache.
+                if (!blockNumber || (blockNumber && cachedPool.block == blockNumber)) {
+                    poolAddressToPool[poolAddress] = cachedPool.pair;
+                    continue;
+                }
+            }
+            poolsToGetTokenPairs.push([token0, token1]);
+            poolsToGetAddresses.push(poolAddress);
+        }
+        log.info({
+            poolsFound: _.map(Object.values(poolAddressToPool), (p) => p.token0.symbol + ' ' + p.token1.symbol),
+            poolsToGetTokenPairs: _.map(poolsToGetTokenPairs, (t) => t[0].symbol + ' ' + t[1].symbol),
+        }, `Found ${Object.keys(poolAddressToPool).length} V2 pools already in local cache for block ${blockNumber}. About to get reserves for ${poolsToGetTokenPairs.length} pools.`);
+        if (poolsToGetAddresses.length > 0) {
+            const poolAccessor = await this.poolProvider.getPools(poolsToGetTokenPairs, {
+                ...providerConfig,
+                enableFeeOnTransferFeeFetching: true,
+            });
+            for (const address of poolsToGetAddresses) {
+                const pool = poolAccessor.getPoolByAddress(address);
+                if (pool) {
+                    poolAddressToPool[address] = pool;
+                    // We don't want to wait for this caching to complete before returning the pools.
+                    this.cache.set(this.POOL_KEY(this.chainId, address), {
+                        pair: pool,
+                        block: blockNumber,
+                    });
+                }
+            }
+        }
+        return {
+            getPool: (tokenA, tokenB) => {
+                const { poolAddress } = this.getPoolAddress(tokenA, tokenB);
+                return poolAddressToPool[poolAddress];
+            },
+            getPoolByAddress: (address) => poolAddressToPool[address],
+            getAllPools: () => Object.values(poolAddressToPool),
+        };
+    }
+    getPoolAddress(tokenA, tokenB) {
+        return this.poolProvider.getPoolAddress(tokenA, tokenB);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,19 @@
+import { ChainId } from '@ring-protocol/sdk-core';
+import { CachingSubgraphProvider } from '../caching-subgraph-provider';
+import { ICache } from './../cache';
+import { IV2SubgraphProvider, V2SubgraphPool } from './subgraph-provider';
+/**
+ * Provider for getting V2 pools, with functionality for caching the results.
+ *
+ * @export
+ * @class CachingV2SubgraphProvider
+ */
+export declare class CachingV2SubgraphProvider extends CachingSubgraphProvider<V2SubgraphPool> implements IV2SubgraphProvider {
+    /**
+     * Creates an instance of CachingV2SubgraphProvider.
+     * @param chainId The chain id to use.
+     * @param subgraphProvider The provider to use to get the subgraph pools when not in the cache.
+     * @param cache Cache instance to hold cached pools.
+     */
+    constructor(chainId: ChainId, subgraphProvider: IV2SubgraphProvider, cache: ICache<V2SubgraphPool[]>);
+}

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

@@ -0,0 +1,20 @@
+import { Protocol } from '@ring-protocol/router-sdk';
+import { CachingSubgraphProvider } from '../caching-subgraph-provider';
+/**
+ * Provider for getting V2 pools, with functionality for caching the results.
+ *
+ * @export
+ * @class CachingV2SubgraphProvider
+ */
+export class CachingV2SubgraphProvider extends CachingSubgraphProvider {
+    /**
+     * Creates an instance of CachingV2SubgraphProvider.
+     * @param chainId The chain id to use.
+     * @param subgraphProvider The provider to use to get the subgraph pools when not in the cache.
+     * @param cache Cache instance to hold cached pools.
+     */
+    constructor(chainId, subgraphProvider, cache) {
+        super(chainId, subgraphProvider, cache, Protocol.V2);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FjaGluZy1zdWJncmFwaC1wcm92aWRlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9wcm92aWRlcnMvdjIvY2FjaGluZy1zdWJncmFwaC1wcm92aWRlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sMkJBQTJCLENBQUM7QUFHckQsT0FBTyxFQUFFLHVCQUF1QixFQUFFLE1BQU0sOEJBQThCLENBQUM7QUFLdkU7Ozs7O0dBS0c7QUFDSCxNQUFNLE9BQU8seUJBQ1gsU0FBUSx1QkFBdUM7SUFFL0M7Ozs7O09BS0c7SUFDSCxZQUNFLE9BQWdCLEVBQ2hCLGdCQUFxQyxFQUNyQyxLQUErQjtRQUUvQixLQUFLLENBQUMsT0FBTyxFQUFFLGdCQUFnQixFQUFFLEtBQUssRUFBRSxRQUFRLENBQUMsRUFBRSxDQUFDLENBQUM7SUFDdkQsQ0FBQztDQUNGIn0=

package/build/module/providers/v2/pool-provider.d.ts

@@ -0,0 +1,63 @@
+import { ChainId, Token } from '@ring-protocol/sdk-core';
+import { Pair } from '@ring-protocol/v2-sdk';
+import { Options as RetryOptions } from 'async-retry';
+import { IMulticallProvider } from '../multicall-provider';
+import { ProviderConfig } from '../provider';
+import { ITokenPropertiesProvider } from '../token-properties-provider';
+/**
+ * Provider for getting V2 pools.
+ *
+ * @export
+ * @interface IV2PoolProvider
+ */
+export interface IV2PoolProvider {
+    /**
+     * Gets the pools for the specified token pairs.
+     *
+     * @param tokenPairs The token pairs to get.
+     * @param [providerConfig] The provider config.
+     * @returns A pool accessor with methods for accessing the pools.
+     */
+    getPools(tokenPairs: [Token, Token][], providerConfig?: ProviderConfig): Promise<V2PoolAccessor>;
+    /**
+     * Gets the pool address for the specified token pair.
+     *
+     * @param tokenA Token A in the pool.
+     * @param tokenB Token B in the pool.
+     * @returns The pool address and the two tokens.
+     */
+    getPoolAddress(tokenA: Token, tokenB: Token): {
+        poolAddress: string;
+        token0: Token;
+        token1: Token;
+    };
+}
+export declare type V2PoolAccessor = {
+    getPool: (tokenA: Token, tokenB: Token) => Pair | undefined;
+    getPoolByAddress: (address: string) => Pair | undefined;
+    getAllPools: () => Pair[];
+};
+export declare type V2PoolRetryOptions = RetryOptions;
+export declare class V2PoolProvider implements IV2PoolProvider {
+    protected chainId: ChainId;
+    protected multicall2Provider: IMulticallProvider;
+    protected tokenPropertiesProvider: ITokenPropertiesProvider;
+    protected retryOptions: V2PoolRetryOptions;
+    private POOL_ADDRESS_CACHE;
+    /**
+     * 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(chainId: ChainId, multicall2Provider: IMulticallProvider, tokenPropertiesProvider: ITokenPropertiesProvider, retryOptions?: V2PoolRetryOptions);
+    getPools(tokenPairs: [Token, Token][], providerConfig?: ProviderConfig): Promise<V2PoolAccessor>;
+    getPoolAddress(tokenA: Token, tokenB: Token): {
+        poolAddress: string;
+        token0: Token;
+        token1: Token;
+    };
+    private getPoolsData;
+    private flatten;
+}

package/build/module/providers/v2/pool-provider.js

@@ -0,0 +1,141 @@
+import { Token } from '@ring-protocol/sdk-core';
+import { Pair } from '@ring-protocol/v2-sdk';
+import retry 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 { log } from '../../util/log';
+import { poolToString } from '../../util/routes';
+import { TokenValidationResult } from '../token-validator-provider';
+export class V2PoolProvider {
+    /**
+     * 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(chainId, multicall2Provider, tokenPropertiesProvider, retryOptions = {
+        retries: 2,
+        minTimeout: 50,
+        maxTimeout: 500,
+    }) {
+        this.chainId = chainId;
+        this.multicall2Provider = multicall2Provider;
+        this.tokenPropertiesProvider = tokenPropertiesProvider;
+        this.retryOptions = retryOptions;
+        // Computing pool addresses is slow as it requires hashing, encoding etc.
+        // Addresses never change so can always be cached.
+        this.POOL_ADDRESS_CACHE = {};
+    }
+    async getPools(tokenPairs, providerConfig) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+        const poolAddressSet = new Set();
+        const sortedTokenPairs = [];
+        const sortedPoolAddresses = [];
+        for (const tokenPair of tokenPairs) {
+            const [tokenA, tokenB] = tokenPair;
+            const { poolAddress, token0, token1 } = this.getPoolAddress(tokenA, tokenB);
+            if (poolAddressSet.has(poolAddress)) {
+                continue;
+            }
+            poolAddressSet.add(poolAddress);
+            sortedTokenPairs.push([token0, token1]);
+            sortedPoolAddresses.push(poolAddress);
+        }
+        log.debug(`getPools called with ${tokenPairs.length} token pairs. Deduped down to ${poolAddressSet.size}`);
+        metric.putMetric('V2_RPC_POOL_RPC_CALL', 1, MetricLoggerUnit.None);
+        metric.putMetric('V2GetReservesBatchSize', sortedPoolAddresses.length, MetricLoggerUnit.Count);
+        metric.putMetric(`V2GetReservesBatchSize_${ID_TO_NETWORK_NAME(this.chainId)}`, sortedPoolAddresses.length, MetricLoggerUnit.Count);
+        const [reservesResults, tokenPropertiesMap] = await Promise.all([
+            (async () => {
+                const beforeReserves = Date.now();
+                const result = await this.getPoolsData(sortedPoolAddresses, 'getReserves', providerConfig);
+                metric.putMetric('V2GetReservesLatency', Date.now() - beforeReserves, MetricLoggerUnit.Milliseconds);
+                return result;
+            })(),
+            (async () => {
+                const beforeTokenProperties = Date.now();
+                const result = await this.tokenPropertiesProvider.getTokensProperties(this.flatten(tokenPairs), providerConfig);
+                metric.putMetric('V2GetTokenPropertiesLatency', Date.now() - beforeTokenProperties, MetricLoggerUnit.Milliseconds);
+                return result;
+            })(),
+        ]);
+        log.info(`Got reserves for ${poolAddressSet.size} pools ${(providerConfig === null || providerConfig === void 0 ? void 0 : providerConfig.blockNumber)
+            ? `as of block: ${await (providerConfig === null || providerConfig === void 0 ? void 0 : providerConfig.blockNumber)}.`
+            : ``}`);
+        const poolAddressToPool = {};
+        const invalidPools = [];
+        for (let i = 0; i < sortedPoolAddresses.length; i++) {
+            const reservesResult = reservesResults[i];
+            if (!(reservesResult === null || reservesResult === void 0 ? void 0 : reservesResult.success)) {
+                const [token0, token1] = sortedTokenPairs[i];
+                invalidPools.push([token0, token1]);
+                continue;
+            }
+            let [token0, token1] = sortedTokenPairs[i];
+            if (((_a = tokenPropertiesMap[token0.address.toLowerCase()]) === null || _a === void 0 ? void 0 : _a.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
+                (_c = (_b = tokenPropertiesMap[token0.address.toLowerCase()]) === null || _b === void 0 ? void 0 : _b.tokenFeeResult) === null || _c === void 0 ? void 0 : _c.buyFeeBps, (_e = (_d = tokenPropertiesMap[token0.address.toLowerCase()]) === null || _d === void 0 ? void 0 : _d.tokenFeeResult) === null || _e === void 0 ? void 0 : _e.sellFeeBps);
+            }
+            if (((_f = tokenPropertiesMap[token1.address.toLowerCase()]) === null || _f === void 0 ? void 0 : _f.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
+                (_h = (_g = tokenPropertiesMap[token1.address.toLowerCase()]) === null || _g === void 0 ? void 0 : _g.tokenFeeResult) === null || _h === void 0 ? void 0 : _h.buyFeeBps, (_k = (_j = tokenPropertiesMap[token1.address.toLowerCase()]) === null || _j === void 0 ? void 0 : _j.tokenFeeResult) === null || _k === void 0 ? void 0 : _k.sellFeeBps);
+            }
+            const { reserve0, reserve1 } = reservesResult.result;
+            const pool = new Pair(CurrencyAmount.fromRawAmount(token0, reserve0.toString()), CurrencyAmount.fromRawAmount(token1, reserve1.toString()));
+            const poolAddress = sortedPoolAddresses[i];
+            poolAddressToPool[poolAddress] = pool;
+        }
+        if (invalidPools.length > 0) {
+            log.info({
+                invalidPools: _.map(invalidPools, ([token0, token1]) => `${token0.symbol}/${token1.symbol}`),
+            }, `${invalidPools.length} pools invalid after checking their slot0 and liquidity results. Dropping.`);
+        }
+        const poolStrs = _.map(Object.values(poolAddressToPool), poolToString);
+        log.debug({ poolStrs }, `Found ${poolStrs.length} valid pools`);
+        return {
+            getPool: (tokenA, tokenB) => {
+                const { poolAddress } = this.getPoolAddress(tokenA, tokenB);
+                return poolAddressToPool[poolAddress];
+            },
+            getPoolByAddress: (address) => poolAddressToPool[address],
+            getAllPools: () => Object.values(poolAddressToPool),
+        };
+    }
+    getPoolAddress(tokenA, tokenB) {
+        const [token0, token1] = tokenA.sortsBefore(tokenB)
+            ? [tokenA, tokenB]
+            : [tokenB, tokenA];
+        const cacheKey = `${this.chainId}/${token0.address}/${token1.address}`;
+        const cachedAddress = this.POOL_ADDRESS_CACHE[cacheKey];
+        if (cachedAddress) {
+            return { poolAddress: cachedAddress, token0, token1 };
+        }
+        const poolAddress = Pair.getAddress(token0, token1);
+        this.POOL_ADDRESS_CACHE[cacheKey] = poolAddress;
+        return { poolAddress, token0, token1 };
+    }
+    async getPoolsData(poolAddresses, functionName, providerConfig) {
+        const { results, blockNumber } = await retry(async () => {
+            return this.multicall2Provider.callSameFunctionOnMultipleContracts({
+                addresses: poolAddresses,
+                contractInterface: IUniswapV2Pair__factory.createInterface(),
+                functionName: functionName,
+                providerConfig,
+            });
+        }, this.retryOptions);
+        log.debug(`Pool data fetched as of block ${blockNumber}`);
+        return results;
+    }
+    // We are using ES2017. ES2019 has native flatMap support
+    flatten(tokenPairs) {
+        const tokens = new Array();
+        for (const [tokenA, tokenB] of tokenPairs) {
+            tokens.push(tokenA);
+            tokens.push(tokenB);
+        }
+        return tokens;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pool-provider.js","sourceRoot":"","sources":["../../../../src/providers/v2/pool-provider.ts"],"names":[],"mappings":"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"}

package/build/module/providers/v2/quote-provider.d.ts

@@ -0,0 +1,34 @@
+import { BigNumber } from '@ethersproject/bignumber';
+import { V2Route } from '../../routers/router';
+import { CurrencyAmount } from '../../util/amounts';
+import { ProviderConfig } from '../provider';
+export declare type V2AmountQuote = {
+    amount: CurrencyAmount;
+    quote: BigNumber | null;
+};
+export declare type V2RouteWithQuotes = [V2Route, V2AmountQuote[]];
+export interface IV2QuoteProvider {
+    getQuotesManyExactIn(amountIns: CurrencyAmount[], routes: V2Route[], providerConfig: ProviderConfig): Promise<{
+        routesWithQuotes: V2RouteWithQuotes[];
+    }>;
+    getQuotesManyExactOut(amountOuts: CurrencyAmount[], routes: V2Route[], providerConfig: ProviderConfig): Promise<{
+        routesWithQuotes: V2RouteWithQuotes[];
+    }>;
+}
+/**
+ * Computes quotes for V2 off-chain. Quotes are computed using the balances
+ * of the pools within each route provided.
+ *
+ * @export
+ * @class V2QuoteProvider
+ */
+export declare class V2QuoteProvider implements IV2QuoteProvider {
+    constructor();
+    getQuotesManyExactIn(amountIns: CurrencyAmount[], routes: V2Route[], providerConfig: ProviderConfig): Promise<{
+        routesWithQuotes: V2RouteWithQuotes[];
+    }>;
+    getQuotesManyExactOut(amountOuts: CurrencyAmount[], routes: V2Route[], providerConfig: ProviderConfig): Promise<{
+        routesWithQuotes: V2RouteWithQuotes[];
+    }>;
+    private getQuotes;
+}

package/build/module/providers/v2/quote-provider.js

@@ -0,0 +1,86 @@
+import { BigNumber } from '@ethersproject/bignumber';
+import { TradeType } from '@ring-protocol/sdk-core';
+import { InsufficientInputAmountError, InsufficientReservesError, } from '@ring-protocol/v2-sdk';
+import { log } from '../../util/log';
+import { routeToString } from '../../util/routes';
+/**
+ * Computes quotes for V2 off-chain. Quotes are computed using the balances
+ * of the pools within each route provided.
+ *
+ * @export
+ * @class V2QuoteProvider
+ */
+export class V2QuoteProvider {
+    /* eslint-disable @typescript-eslint/no-empty-function */
+    constructor() { }
+    /* eslint-enable @typescript-eslint/no-empty-function */
+    async getQuotesManyExactIn(amountIns, routes, providerConfig) {
+        return this.getQuotes(amountIns, routes, TradeType.EXACT_INPUT, providerConfig);
+    }
+    async getQuotesManyExactOut(amountOuts, routes, providerConfig) {
+        return this.getQuotes(amountOuts, routes, TradeType.EXACT_OUTPUT, providerConfig);
+    }
+    async getQuotes(amounts, routes, tradeType, providerConfig) {
+        const routesWithQuotes = [];
+        const debugStrs = [];
+        for (const route of routes) {
+            const amountQuotes = [];
+            let insufficientInputAmountErrorCount = 0;
+            let insufficientReservesErrorCount = 0;
+            for (const amount of amounts) {
+                try {
+                    if (tradeType == TradeType.EXACT_INPUT) {
+                        let outputAmount = amount.wrapped;
+                        for (const pair of route.pairs) {
+                            [outputAmount] = pair.getOutputAmount(outputAmount, providerConfig.enableFeeOnTransferFeeFetching === true);
+                        }
+                        amountQuotes.push({
+                            amount,
+                            quote: BigNumber.from(outputAmount.quotient.toString()),
+                        });
+                    }
+                    else {
+                        let inputAmount = amount.wrapped;
+                        for (let i = route.pairs.length - 1; i >= 0; i--) {
+                            const pair = route.pairs[i];
+                            [inputAmount] = pair.getInputAmount(inputAmount, providerConfig.enableFeeOnTransferFeeFetching === true);
+                        }
+                        amountQuotes.push({
+                            amount,
+                            quote: BigNumber.from(inputAmount.quotient.toString()),
+                        });
+                    }
+                }
+                catch (err) {
+                    // Can fail to get quotes, e.g. throws InsufficientReservesError or InsufficientInputAmountError.
+                    if (err instanceof InsufficientInputAmountError) {
+                        insufficientInputAmountErrorCount =
+                            insufficientInputAmountErrorCount + 1;
+                        amountQuotes.push({ amount, quote: null });
+                    }
+                    else if (err instanceof InsufficientReservesError) {
+                        insufficientReservesErrorCount = insufficientReservesErrorCount + 1;
+                        amountQuotes.push({ amount, quote: null });
+                    }
+                    else {
+                        throw err;
+                    }
+                }
+            }
+            if (insufficientInputAmountErrorCount > 0 ||
+                insufficientReservesErrorCount > 0) {
+                debugStrs.push(`${[
+                    routeToString(route),
+                ]} Input: ${insufficientInputAmountErrorCount} Reserves: ${insufficientReservesErrorCount} }`);
+            }
+            routesWithQuotes.push([route, amountQuotes]);
+        }
+        if (debugStrs.length > 0) {
+            log.info({ debugStrs }, `Failed quotes for V2 routes`);
+        }
+        return {
+            routesWithQuotes,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,19 @@
+import { ChainId, Token } from '@ring-protocol/sdk-core';
+import { IV2SubgraphProvider, V2SubgraphPool } from './subgraph-provider';
+/**
+ * Provider that does not get data from an external source and instead returns
+ * a hardcoded list of Subgraph pools.
+ *
+ * Since the pools are hardcoded, the liquidity/price values are dummys and should not
+ * be depended on.
+ *
+ * Useful for instances where other data sources are unavailable. E.g. subgraph not available.
+ *
+ * @export
+ * @class StaticV2SubgraphProvider
+ */
+export declare class StaticV2SubgraphProvider implements IV2SubgraphProvider {
+    private chainId;
+    constructor(chainId: ChainId);
+    getPools(tokenIn?: Token, tokenOut?: Token): Promise<V2SubgraphPool[]>;
+}