@xspswap/smart-order-router 1.0.0

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

@@ -0,0 +1,110 @@
+import { Token } from '@uniswap/sdk-core';
+import _ from 'lodash';
+import { IERC20Metadata__factory } from '../types/v3/factories/IERC20Metadata__factory';
+import { ChainId, log, WRAPPED_NATIVE_CURRENCY } from '../util';
+// Some well known tokens on each chain for seeding cache / testing.
+export const USDT_XDC_APOTHEM = new Token(ChainId.XDC_APOTHEM, '0xac4cdD44931d4A0Ff6B1Ea9206e02FeaC8EB9a50', 6, 'USDT', 'Tether Token');
+export const USDC_XDC_APOTHEM = new Token(ChainId.XDC_APOTHEM, '0xDF5038D080Ca5bd21c6c90F0b004306a26Af4bA8', 18, 'USDC', 'USDC');
+export const DAI_XDC_APOTHEM = new Token(ChainId.XDC_APOTHEM, '0xE46554Ad93a7046C85f2dA0C20EbD68e41f11b36', 18, 'DAI', 'DAI Stablecoin on XDC testnet');
+export const WBTC_XDC_APOTHEM = new Token(ChainId.XDC_APOTHEM, '0x885c04a08FbE1C6059f407E36c35B165704D1A03', 8, 'WBTC', 'Wrapped BTC');
+export const XSP_XDC = new Token(ChainId.XDC, '0x36726235dAdbdb4658D33E62a249dCA7c4B2bC68', 18, 'XSP', 'XSwapProtocol');
+export const XTT_XDC = new Token(ChainId.XDC, '0x17476dc3eda45aD916cEAdDeA325B240A7FB259D', 18, 'XTT', 'XSwap Treasury Token');
+export const SRX_XDC = new Token(ChainId.XDC, '0x5D5f074837f5d4618B3916ba74De1Bf9662a3fEd', 18, 'SRX', 'StoreX');
+export const PRNT_XDC = new Token(ChainId.XDC, '0x0e11710aad67e7427cfbc12c353284c2e335f62c', 18, 'PRNT', 'PrimeNumbers Token');
+export const USDT_XDC = new Token(ChainId.XDC, '0xd4b5f10d61916bd6e0860144a91ac658de8a1437', 6, 'xUSDT', 'USDT@xinfin');
+export const WXDC_XDC = new Token(ChainId.XDC, '0x951857744785e80e2de051c32ee7b25f9c458c42', 18, 'WXDC', 'Wrapped XDC');
+export class TokenProvider {
+    constructor(chainId, multicall2Provider) {
+        this.chainId = chainId;
+        this.multicall2Provider = multicall2Provider;
+    }
+    async getTokens(_addresses, providerConfig) {
+        const addressToToken = {};
+        const symbolToToken = {};
+        const addresses = _(_addresses)
+            .map((address) => address.toLowerCase())
+            .uniq()
+            .value();
+        if (addresses.length > 0) {
+            const [symbolsResult, decimalsResult] = await Promise.all([
+                this.multicall2Provider.callSameFunctionOnMultipleContracts({
+                    addresses,
+                    contractInterface: IERC20Metadata__factory.createInterface(),
+                    functionName: 'symbol',
+                    providerConfig,
+                }),
+                this.multicall2Provider.callSameFunctionOnMultipleContracts({
+                    addresses,
+                    contractInterface: IERC20Metadata__factory.createInterface(),
+                    functionName: 'decimals',
+                    providerConfig,
+                }),
+            ]);
+            const { results: symbols } = symbolsResult;
+            const { results: decimals } = decimalsResult;
+            for (let i = 0; i < addresses.length; i++) {
+                const address = addresses[i];
+                const symbolResult = symbols[i];
+                const decimalResult = decimals[i];
+                if (!(symbolResult === null || symbolResult === void 0 ? void 0 : symbolResult.success) || !(decimalResult === null || decimalResult === void 0 ? void 0 : decimalResult.success)) {
+                    log.info({
+                        symbolResult,
+                        decimalResult,
+                    }, `Dropping token with address ${address} as symbol or decimal are invalid`);
+                    continue;
+                }
+                const symbol = symbolResult.result[0];
+                const decimal = decimalResult.result[0];
+                addressToToken[address.toLowerCase()] = new Token(this.chainId, address, decimal, symbol);
+                symbolToToken[symbol.toLowerCase()] =
+                    addressToToken[address.toLowerCase()];
+            }
+            log.info(`Got token symbol and decimals for ${Object.values(addressToToken).length} out of ${addresses.length} tokens on-chain ${providerConfig ? `as of: ${providerConfig === null || providerConfig === void 0 ? void 0 : providerConfig.blockNumber}` : ''}`);
+        }
+        return {
+            getTokenByAddress: (address) => {
+                return addressToToken[address.toLowerCase()];
+            },
+            getTokenBySymbol: (symbol) => {
+                return symbolToToken[symbol.toLowerCase()];
+            },
+            getAllTokens: () => {
+                return Object.values(addressToToken);
+            },
+        };
+    }
+}
+export const DAI_ON = (chainId) => {
+    switch (chainId) {
+        // case ChainId.XDC:
+        //   return USDT_BSC;
+        case ChainId.XDC_APOTHEM:
+            return DAI_XDC_APOTHEM;
+        default:
+            throw new Error(`Chain id: ${chainId} not supported`);
+    }
+};
+export const USDT_ON = (chainId) => {
+    switch (chainId) {
+        case ChainId.XDC:
+            return USDT_XDC;
+        case ChainId.XDC_APOTHEM:
+            return USDT_XDC_APOTHEM;
+        default:
+            throw new Error(`Chain id: ${chainId} not supported`);
+    }
+};
+export const USDC_ON = (chainId) => {
+    switch (chainId) {
+        case ChainId.XDC:
+            return USDT_XDC;
+        case ChainId.XDC_APOTHEM:
+            return USDC_XDC_APOTHEM;
+        default:
+            throw new Error(`Chain id: ${chainId} not supported`);
+    }
+};
+export const WNATIVE_ON = (chainId) => {
+    return WRAPPED_NATIVE_CURRENCY[chainId];
+};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,42 @@
+import { Token } from '@uniswap/sdk-core';
+import { ChainId } from '../util';
+import { ICache } from './cache';
+import { IMulticallProvider } from './multicall-provider';
+import { ProviderConfig } from './provider';
+export declare enum TokenValidationResult {
+    UNKN = 0,
+    FOT = 1,
+    STF = 2
+}
+export interface TokenValidationResults {
+    getValidationByToken(token: Token): TokenValidationResult | undefined;
+}
+/**
+ * Provider for getting token data.
+ *
+ * @export
+ * @interface ITokenValidatorProvider
+ */
+export interface ITokenValidatorProvider {
+    /**
+     * 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.
+     */
+    validateTokens(tokens: Token[], providerConfig?: ProviderConfig): Promise<TokenValidationResults>;
+}
+export declare class TokenValidatorProvider implements ITokenValidatorProvider {
+    protected chainId: ChainId;
+    protected multicall2Provider: IMulticallProvider;
+    private tokenValidationCache;
+    private tokenValidatorAddress;
+    private gasLimitPerCall;
+    private amountToFlashBorrow;
+    private allowList;
+    private CACHE_KEY;
+    private BASES;
+    constructor(chainId: ChainId, multicall2Provider: IMulticallProvider, tokenValidationCache: ICache<TokenValidationResult>, tokenValidatorAddress?: string, gasLimitPerCall?: number, amountToFlashBorrow?: string, allowList?: Set<string>);
+    validateTokens(tokens: Token[], providerConfig?: ProviderConfig): Promise<TokenValidationResults>;
+}

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

@@ -0,0 +1,88 @@
+import _ from 'lodash';
+import { ITokenValidator__factory } from '../types/other/factories/ITokenValidator__factory';
+import { log, WRAPPED_NATIVE_CURRENCY } from '../util';
+const DEFAULT_ALLOWLIST = new Set([
+    // RYOSHI. Does not allow transfers between contracts so fails validation.
+    '0x777E2ae845272a2F540ebf6a3D03734A5a8f618e'.toLowerCase(),
+]);
+export var TokenValidationResult;
+(function (TokenValidationResult) {
+    TokenValidationResult[TokenValidationResult["UNKN"] = 0] = "UNKN";
+    TokenValidationResult[TokenValidationResult["FOT"] = 1] = "FOT";
+    TokenValidationResult[TokenValidationResult["STF"] = 2] = "STF";
+})(TokenValidationResult || (TokenValidationResult = {}));
+const TOKEN_VALIDATOR_ADDRESS = '0x13E9fA07eBf6d019B5be08b3C450FacaA6Dd1AFe';
+const AMOUNT_TO_FLASH_BORROW = '1000';
+const GAS_LIMIT_PER_VALIDATE = 1000000;
+export class TokenValidatorProvider {
+    constructor(chainId, multicall2Provider, tokenValidationCache, tokenValidatorAddress = TOKEN_VALIDATOR_ADDRESS, gasLimitPerCall = GAS_LIMIT_PER_VALIDATE, amountToFlashBorrow = AMOUNT_TO_FLASH_BORROW, allowList = DEFAULT_ALLOWLIST) {
+        this.chainId = chainId;
+        this.multicall2Provider = multicall2Provider;
+        this.tokenValidationCache = tokenValidationCache;
+        this.tokenValidatorAddress = tokenValidatorAddress;
+        this.gasLimitPerCall = gasLimitPerCall;
+        this.amountToFlashBorrow = amountToFlashBorrow;
+        this.allowList = allowList;
+        this.CACHE_KEY = (chainId, address) => `token-${chainId}-${address}`;
+        this.BASES = [WRAPPED_NATIVE_CURRENCY[this.chainId].address];
+    }
+    async validateTokens(tokens, providerConfig) {
+        const tokenAddressToToken = _.keyBy(tokens, 'address');
+        const addressesRaw = _(tokens)
+            .map((token) => token.address)
+            .uniq()
+            .value();
+        const addresses = [];
+        const tokenToResult = {};
+        // Check if we have cached token validation results for any tokens.
+        for (const address of addressesRaw) {
+            if (await this.tokenValidationCache.has(this.CACHE_KEY(this.chainId, address))) {
+                tokenToResult[address.toLowerCase()] =
+                    (await this.tokenValidationCache.get(this.CACHE_KEY(this.chainId, address)));
+            }
+            else {
+                addresses.push(address);
+            }
+        }
+        log.info(`Got token validation results for ${addressesRaw.length - addresses.length} tokens from cache. Getting ${addresses.length} on-chain.`);
+        const functionParams = _(addresses)
+            .map((address) => [address, this.BASES, this.amountToFlashBorrow])
+            .value();
+        // 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 multicallResult = await this.multicall2Provider.callSameFunctionOnContractWithMultipleParams({
+            address: this.tokenValidatorAddress,
+            contractInterface: ITokenValidator__factory.createInterface(),
+            functionName: 'validate',
+            functionParams: functionParams,
+            providerConfig,
+            additionalConfig: {
+                gasLimitPerCallOverride: this.gasLimitPerCall,
+            },
+        });
+        for (let i = 0; i < multicallResult.results.length; i++) {
+            const resultWrapper = multicallResult.results[i];
+            const tokenAddress = addresses[i];
+            const token = tokenAddressToToken[tokenAddress];
+            if (this.allowList.has(token.address.toLowerCase())) {
+                tokenToResult[token.address.toLowerCase()] = TokenValidationResult.UNKN;
+                await this.tokenValidationCache.set(this.CACHE_KEY(this.chainId, token.address.toLowerCase()), tokenToResult[token.address.toLowerCase()]);
+                continue;
+            }
+            // Could happen if the tokens transfer consumes too much gas so we revert. Just
+            // drop the token in that case.
+            if (!resultWrapper.success) {
+                log.info({ result: resultWrapper }, `Failed to validate token ${token.symbol}`);
+                continue;
+            }
+            const validationResult = resultWrapper.result[0];
+            tokenToResult[token.address.toLowerCase()] =
+                validationResult;
+            await this.tokenValidationCache.set(this.CACHE_KEY(this.chainId, token.address.toLowerCase()), tokenToResult[token.address.toLowerCase()]);
+        }
+        return {
+            getValidationByToken: (token) => tokenToResult[token.address.toLowerCase()],
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,20 @@
+import { ChainId } from '../util/chains';
+import { V2SubgraphPool } from './v2/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 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,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

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

@@ -0,0 +1,34 @@
+import { Token } from '@uniswap/sdk-core';
+import { Pair } from '@xswap-v3/v2-sdk';
+import { ChainId } from '../../util/chains';
+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,81 @@
+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);
+            for (const address of poolsToGetAddresses) {
+                const pool = poolAccessor.getPoolByAddress(address);
+                if (pool) {
+                    poolAddressToPool[address] = pool;
+                    await 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,23 @@
+import { ChainId } from '../../util/chains';
+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 implements IV2SubgraphProvider {
+    private chainId;
+    protected subgraphProvider: IV2SubgraphProvider;
+    private cache;
+    private SUBGRAPH_KEY;
+    /**
+     * 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[]>);
+    getPools(): Promise<V2SubgraphPool[]>;
+}

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

@@ -0,0 +1,30 @@
+/**
+ * Provider for getting V2 pools, with functionality for caching the results.
+ *
+ * @export
+ * @class CachingV2SubgraphProvider
+ */
+export class CachingV2SubgraphProvider {
+    /**
+     * 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) {
+        this.chainId = chainId;
+        this.subgraphProvider = subgraphProvider;
+        this.cache = cache;
+        this.SUBGRAPH_KEY = (chainId) => `subgraph-pools-v2-${chainId}`;
+    }
+    async getPools() {
+        const cachedPools = await this.cache.get(this.SUBGRAPH_KEY(this.chainId));
+        if (cachedPools) {
+            return cachedPools;
+        }
+        const pools = await this.subgraphProvider.getPools();
+        await this.cache.set(this.SUBGRAPH_KEY(this.chainId), pools);
+        return pools;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FjaGluZy1zdWJncmFwaC1wcm92aWRlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9wcm92aWRlcnMvdjIvY2FjaGluZy1zdWJncmFwaC1wcm92aWRlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFLQTs7Ozs7R0FLRztBQUNILE1BQU0sT0FBTyx5QkFBeUI7SUFHcEM7Ozs7O09BS0c7SUFDSCxZQUNVLE9BQWdCLEVBQ2QsZ0JBQXFDLEVBQ3ZDLEtBQStCO1FBRi9CLFlBQU8sR0FBUCxPQUFPLENBQVM7UUFDZCxxQkFBZ0IsR0FBaEIsZ0JBQWdCLENBQXFCO1FBQ3ZDLFVBQUssR0FBTCxLQUFLLENBQTBCO1FBWGpDLGlCQUFZLEdBQUcsQ0FBQyxPQUFnQixFQUFFLEVBQUUsQ0FBQyxxQkFBcUIsT0FBTyxFQUFFLENBQUM7SUFZekUsQ0FBQztJQUVHLEtBQUssQ0FBQyxRQUFRO1FBQ25CLE1BQU0sV0FBVyxHQUFHLE1BQU0sSUFBSSxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLFlBQVksQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQztRQUUxRSxJQUFJLFdBQVcsRUFBRTtZQUNmLE9BQU8sV0FBVyxDQUFDO1NBQ3BCO1FBRUQsTUFBTSxLQUFLLEdBQUcsTUFBTSxJQUFJLENBQUMsZ0JBQWdCLENBQUMsUUFBUSxFQUFFLENBQUM7UUFFckQsTUFBTSxJQUFJLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsWUFBWSxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsRUFBRSxLQUFLLENBQUMsQ0FBQztRQUU3RCxPQUFPLEtBQUssQ0FBQztJQUNmLENBQUM7Q0FDRiJ9

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

@@ -0,0 +1,60 @@
+import { Token } from '@uniswap/sdk-core';
+import { Pair } from '@xswap-v3/v2-sdk';
+import { Options as RetryOptions } from 'async-retry';
+import { ChainId } from '../../util';
+import { IMulticallProvider } from '../multicall-provider';
+import { ProviderConfig } from '../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 type V2PoolAccessor = {
+    getPool: (tokenA: Token, tokenB: Token) => Pair | undefined;
+    getPoolByAddress: (address: string) => Pair | undefined;
+    getAllPools: () => Pair[];
+};
+export type V2PoolRetryOptions = RetryOptions;
+export declare class V2PoolProvider implements IV2PoolProvider {
+    protected chainId: ChainId;
+    protected multicall2Provider: IMulticallProvider;
+    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 retryOptions The retry options for each call to the multicall.
+     */
+    constructor(chainId: ChainId, multicall2Provider: IMulticallProvider, retryOptions?: V2PoolRetryOptions);
+    getPools(tokenPairs: [Token, Token][], providerConfig?: ProviderConfig): Promise<V2PoolAccessor>;
+    getPoolAddress(tokenA: Token, tokenB: Token): {
+        poolAddress: string;
+        token0: Token;
+        token1: Token;
+    };
+    private getPoolsData;
+}