@kumbaya_xyz/smart-order-router 4.22.38

package/build/module/providers/v3/subgraph-provider-with-fallback.d.ts

@@ -0,0 +1,12 @@
+import { SubgraphProviderWithFallBacks } from '../subgraph-provider-with-fallback';
+import { IV3SubgraphProvider, V3SubgraphPool } from './subgraph-provider';
+/**
+ * Provider for getting V3 subgraph pools that falls back to a different provider
+ * in the event of failure.
+ *
+ * @export
+ * @class V3SubgraphProviderWithFallBacks
+ */
+export declare class V3SubgraphProviderWithFallBacks extends SubgraphProviderWithFallBacks<V3SubgraphPool> implements IV3SubgraphProvider {
+    constructor(fallbacks: IV3SubgraphProvider[]);
+}

package/build/module/providers/v3/subgraph-provider-with-fallback.js

@@ -0,0 +1,15 @@
+import { Protocol } from '@uniswap/router-sdk';
+import { SubgraphProviderWithFallBacks } from '../subgraph-provider-with-fallback';
+/**
+ * Provider for getting V3 subgraph pools that falls back to a different provider
+ * in the event of failure.
+ *
+ * @export
+ * @class V3SubgraphProviderWithFallBacks
+ */
+export class V3SubgraphProviderWithFallBacks extends SubgraphProviderWithFallBacks {
+    constructor(fallbacks) {
+        super(fallbacks, Protocol.V3);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3ViZ3JhcGgtcHJvdmlkZXItd2l0aC1mYWxsYmFjay5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9wcm92aWRlcnMvdjMvc3ViZ3JhcGgtcHJvdmlkZXItd2l0aC1mYWxsYmFjay50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFFL0MsT0FBTyxFQUFFLDZCQUE2QixFQUFFLE1BQU0sb0NBQW9DLENBQUM7QUFJbkY7Ozs7OztHQU1HO0FBQ0gsTUFBTSxPQUFPLCtCQUNYLFNBQVEsNkJBQTZDO0lBR3JELFlBQVksU0FBZ0M7UUFDMUMsS0FBSyxDQUFDLFNBQVMsRUFBRSxRQUFRLENBQUMsRUFBRSxDQUFDLENBQUM7SUFDaEMsQ0FBQztDQUNGIn0=

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

@@ -0,0 +1,45 @@
+import { ChainId, Token } from '@uniswap/sdk-core';
+import { ProviderConfig } from '../provider';
+import { SubgraphProvider } from '../subgraph-provider';
+export interface V3SubgraphPool {
+    id: string;
+    feeTier: string;
+    liquidity: string;
+    token0: {
+        id: string;
+    };
+    token1: {
+        id: string;
+    };
+    tvlETH: number;
+    tvlUSD: number;
+}
+export type V3RawSubgraphPool = {
+    id: string;
+    feeTier: string;
+    liquidity: string;
+    token0: {
+        symbol: string;
+        id: string;
+    };
+    token1: {
+        symbol: string;
+        id: string;
+    };
+    totalValueLockedUSD: string;
+    totalValueLockedETH: string;
+    totalValueLockedUSDUntracked: string;
+};
+/**
+ * Provider for getting V3 pools from the Subgraph
+ *
+ * @export
+ * @interface IV3SubgraphProvider
+ */
+export interface IV3SubgraphProvider {
+    getPools(tokenIn?: Token, tokenOut?: Token, providerConfig?: ProviderConfig): Promise<V3SubgraphPool[]>;
+}
+export declare class V3SubgraphProvider extends SubgraphProvider<V3RawSubgraphPool, V3SubgraphPool> implements IV3SubgraphProvider {
+    constructor(chainId: ChainId, retries?: number, timeout?: number, rollback?: boolean, trackedEthThreshold?: number, untrackedUsdThreshold?: number, subgraphUrlOverride?: string, bearerToken?: string);
+    protected mapSubgraphPool(rawPool: V3RawSubgraphPool): V3SubgraphPool;
+}

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

@@ -0,0 +1,42 @@
+import { Protocol } from '@uniswap/router-sdk';
+import { ChainId } from '@uniswap/sdk-core';
+import { SubgraphProvider } from '../subgraph-provider';
+const SUBGRAPH_URL_BY_CHAIN = {
+    [ChainId.MAINNET]: 'https://api.thegraph.com/subgraphs/name/uniswap/uniswap-v3',
+    [ChainId.OPTIMISM]: 'https://api.thegraph.com/subgraphs/name/ianlapham/optimism-post-regenesis',
+    // todo: add once subgraph is live
+    [ChainId.OPTIMISM_SEPOLIA]: '',
+    [ChainId.ARBITRUM_ONE]: 'https://api.thegraph.com/subgraphs/name/ianlapham/arbitrum-minimal',
+    // todo: add once subgraph is live
+    [ChainId.ARBITRUM_SEPOLIA]: '',
+    [ChainId.POLYGON]: 'https://api.thegraph.com/subgraphs/name/ianlapham/uniswap-v3-polygon',
+    [ChainId.CELO]: 'https://api.thegraph.com/subgraphs/name/jesse-sawa/uniswap-celo',
+    [ChainId.GOERLI]: 'https://api.thegraph.com/subgraphs/name/ianlapham/uniswap-v3-gorli',
+    [ChainId.BNB]: 'https://api.thegraph.com/subgraphs/name/ilyamk/uniswap-v3---bnb-chain',
+    [ChainId.AVALANCHE]: 'https://api.thegraph.com/subgraphs/name/lynnshaoyu/uniswap-v3-avax',
+    [ChainId.BASE]: 'https://api.studio.thegraph.com/query/48211/uniswap-v3-base/version/latest',
+    [ChainId.BLAST]: 'https://gateway-arbitrum.network.thegraph.com/api/0ae45f0bf40ae2e73119b44ccd755967/subgraphs/id/2LHovKznvo8YmKC9ZprPjsYAZDCc4K5q4AYz8s3cnQn1',
+};
+export class V3SubgraphProvider extends SubgraphProvider {
+    constructor(chainId, retries = 2, timeout = 30000, rollback = true, trackedEthThreshold = 0.01, untrackedUsdThreshold = Number.MAX_VALUE, subgraphUrlOverride, bearerToken) {
+        super(Protocol.V3, chainId, retries, timeout, rollback, trackedEthThreshold, 0, // trackedZoraEthThreshold is not applicable for V3
+        new Set(), // zoraHooks is not applicable for V3
+        untrackedUsdThreshold, subgraphUrlOverride !== null && subgraphUrlOverride !== void 0 ? subgraphUrlOverride : SUBGRAPH_URL_BY_CHAIN[chainId], bearerToken);
+    }
+    mapSubgraphPool(rawPool) {
+        return {
+            id: rawPool.id,
+            feeTier: rawPool.feeTier,
+            liquidity: rawPool.liquidity,
+            token0: {
+                id: rawPool.token0.id,
+            },
+            token1: {
+                id: rawPool.token1.id,
+            },
+            tvlETH: parseFloat(rawPool.totalValueLockedETH),
+            tvlUSD: parseFloat(rawPool.totalValueLockedUSD),
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,4 @@
+import { URISubgraphProvider } from '../uri-subgraph-provider';
+import { IV3SubgraphProvider, V3SubgraphPool } from './subgraph-provider';
+export declare class V3URISubgraphProvider extends URISubgraphProvider<V3SubgraphPool> implements IV3SubgraphProvider {
+}

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

@@ -0,0 +1,4 @@
+import { URISubgraphProvider } from '../uri-subgraph-provider';
+export class V3URISubgraphProvider extends URISubgraphProvider {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXJpLXN1YmdyYXBoLXByb3ZpZGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3Byb3ZpZGVycy92My91cmktc3ViZ3JhcGgtcHJvdmlkZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sMEJBQTBCLENBQUM7QUFJL0QsTUFBTSxPQUFPLHFCQUNYLFNBQVEsbUJBQW1DO0NBQ1YifQ==

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

@@ -0,0 +1,24 @@
+import { ChainId, Currency } from '@uniswap/sdk-core';
+import { Pool } from '@uniswap/v4-sdk';
+import { ICache } from '../cache';
+import { ProviderConfig } from '../provider';
+import { IV4PoolProvider, V4PoolAccessor } from './pool-provider';
+export declare class CachingV4PoolProvider implements IV4PoolProvider {
+    protected chainId: ChainId;
+    protected poolProvider: IV4PoolProvider;
+    private cache;
+    private POOL_KEY;
+    /**
+     * Creates an instance of CachingV4PoolProvider.
+     * @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: IV4PoolProvider, cache: ICache<Pool>);
+    getPools(currencyPairs: [Currency, Currency, number, number, string][], providerConfig?: ProviderConfig): Promise<V4PoolAccessor>;
+    getPoolId(currencyA: Currency, currencyB: Currency, fee: number, tickSpacing: number, hooks: string): {
+        poolId: string;
+        currency0: Currency;
+        currency1: Currency;
+    };
+}

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

@@ -0,0 +1,74 @@
+import _ from 'lodash';
+import { log, metric, MetricLoggerUnit } from '../../util';
+export class CachingV4PoolProvider {
+    /**
+     * Creates an instance of CachingV4PoolProvider.
+     * @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) {
+        this.chainId = chainId;
+        this.poolProvider = poolProvider;
+        this.cache = cache;
+        this.POOL_KEY = (chainId, address, blockNumber) => blockNumber
+            ? `pool-${chainId}-${address}-${blockNumber}`
+            : `pool-${chainId}-${address}`;
+    }
+    async getPools(currencyPairs, providerConfig) {
+        const poolIdSet = new Set();
+        const poolsToGetCurrencyPairs = [];
+        const poolsToGetIds = [];
+        const poolIdToPool = {};
+        const blockNumber = await (providerConfig === null || providerConfig === void 0 ? void 0 : providerConfig.blockNumber);
+        for (const [currencyA, currencyB, feeAmount, tickSpacing, hooks,] of currencyPairs) {
+            const { poolId, currency0, currency1 } = this.getPoolId(currencyA, currencyB, feeAmount, tickSpacing, hooks);
+            if (poolIdSet.has(poolId)) {
+                continue;
+            }
+            poolIdSet.add(poolId);
+            const cachedPool = await this.cache.get(this.POOL_KEY(this.chainId, poolId, blockNumber));
+            if (cachedPool) {
+                metric.putMetric('V4_INMEMORY_CACHING_POOL_HIT_IN_MEMORY', 1, MetricLoggerUnit.None);
+                poolIdToPool[poolId] = cachedPool;
+                continue;
+            }
+            metric.putMetric('V4_INMEMORY_CACHING_POOL_MISS_NOT_IN_MEMORY', 1, MetricLoggerUnit.None);
+            poolsToGetCurrencyPairs.push([
+                currency0,
+                currency1,
+                feeAmount,
+                tickSpacing,
+                hooks,
+            ]);
+            poolsToGetIds.push(poolId);
+        }
+        log.info({
+            poolsFound: _.map(Object.values(poolIdToPool), (p) => `${p.token0.symbol} ${p.token1.symbol} ${p.fee}`),
+            poolsToGetTokenPairs: _.map(poolsToGetCurrencyPairs, (t) => `${t[0].symbol} ${t[1].symbol} ${t[2]}`),
+        }, `Found ${Object.keys(poolIdToPool).length} V4 pools already in local cache. About to get liquidity and slot0s for ${poolsToGetCurrencyPairs.length} pools.`);
+        if (poolsToGetCurrencyPairs.length > 0) {
+            const poolAccessor = await this.poolProvider.getPools(poolsToGetCurrencyPairs, providerConfig);
+            for (const address of poolsToGetIds) {
+                const pool = poolAccessor.getPoolById(address);
+                if (pool) {
+                    poolIdToPool[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, blockNumber), pool);
+                }
+            }
+        }
+        return {
+            getPool: (currencyA, currencyB, fee, tickSpacing, hooks) => {
+                const { poolId } = this.poolProvider.getPoolId(currencyA, currencyB, fee, tickSpacing, hooks);
+                return poolIdToPool[poolId];
+            },
+            getPoolById: (poolId) => poolIdToPool[poolId],
+            getAllPools: () => Object.values(poolIdToPool),
+        };
+    }
+    getPoolId(currencyA, currencyB, fee, tickSpacing, hooks) {
+        return this.poolProvider.getPoolId(currencyA, currencyB, fee, tickSpacing, hooks);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,19 @@
+import { ChainId } from '@uniswap/sdk-core';
+import { ICache } from '../cache';
+import { CachingSubgraphProvider } from '../caching-subgraph-provider';
+import { IV4SubgraphProvider, V4SubgraphPool } from './subgraph-provider';
+/**
+ * Provider for getting V4 pools, with functionality for caching the results.
+ *
+ * @export
+ * @class CachingV4SubgraphProvider
+ */
+export declare class CachingV4SubgraphProvider extends CachingSubgraphProvider<V4SubgraphPool> implements IV4SubgraphProvider {
+    /**
+     * Creates an instance of CachingV3SubgraphProvider.
+     * @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: IV4SubgraphProvider, cache: ICache<V4SubgraphPool[]>);
+}

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

@@ -0,0 +1,20 @@
+import { Protocol } from '@uniswap/router-sdk';
+import { CachingSubgraphProvider } from '../caching-subgraph-provider';
+/**
+ * Provider for getting V4 pools, with functionality for caching the results.
+ *
+ * @export
+ * @class CachingV4SubgraphProvider
+ */
+export class CachingV4SubgraphProvider extends CachingSubgraphProvider {
+    /**
+     * Creates an instance of CachingV3SubgraphProvider.
+     * @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.V4);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FjaGluZy1zdWJncmFwaC1wcm92aWRlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9wcm92aWRlcnMvdjQvY2FjaGluZy1zdWJncmFwaC1wcm92aWRlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFJL0MsT0FBTyxFQUFFLHVCQUF1QixFQUFFLE1BQU0sOEJBQThCLENBQUM7QUFJdkU7Ozs7O0dBS0c7QUFDSCxNQUFNLE9BQU8seUJBQ1gsU0FBUSx1QkFBdUM7SUFHL0M7Ozs7O09BS0c7SUFDSCxZQUNFLE9BQWdCLEVBQ2hCLGdCQUFxQyxFQUNyQyxLQUErQjtRQUUvQixLQUFLLENBQUMsT0FBTyxFQUFFLGdCQUFnQixFQUFFLEtBQUssRUFBRSxRQUFRLENBQUMsRUFBRSxDQUFDLENBQUM7SUFDdkQsQ0FBQztDQUNGIn0=

package/build/module/providers/v4/euler-swap-hooks-subgraph-provider.d.ts

@@ -0,0 +1,25 @@
+import { ChainId } from '@uniswap/sdk-core';
+import { ProviderConfig } from '../provider';
+import { V4SubgraphPool } from './subgraph-provider';
+export interface EulerSwapHooks {
+    id: string;
+    hook: string;
+    asset0: string;
+    asset1: string;
+    eulerAccount: string;
+}
+export interface ISubgraphProvider {
+    getHooks(providerConfig?: ProviderConfig): Promise<EulerSwapHooks[]>;
+    getPoolByHook(hook: string, providerConfig?: ProviderConfig): Promise<V4SubgraphPool | undefined>;
+}
+export declare class EulerSwapHooksSubgraphProvider implements ISubgraphProvider {
+    private chainId;
+    private retries;
+    private timeout;
+    private rollback;
+    private client;
+    private protocol;
+    constructor(chainId: ChainId, retries?: number, timeout?: number, rollback?: boolean, subgraphUrlOverride?: string | undefined);
+    getHooks(providerConfig?: ProviderConfig): Promise<EulerSwapHooks[]>;
+    getPoolByHook(hook: string, providerConfig?: ProviderConfig): Promise<V4SubgraphPool | undefined>;
+}

package/build/module/providers/v4/euler-swap-hooks-subgraph-provider.js

@@ -0,0 +1,153 @@
+import { Protocol } from '@uniswap/router-sdk';
+import retry from 'async-retry';
+import Timeout from 'await-timeout';
+import { gql, GraphQLClient } from 'graphql-request';
+import _ from 'lodash';
+import { log, metric } from '../../util';
+import { PAGE_SIZE } from '../subgraph-provider';
+import { SUBGRAPH_URL_BY_CHAIN } from './subgraph-provider';
+export class EulerSwapHooksSubgraphProvider {
+    constructor(chainId, retries = 2, timeout = 30000, rollback = true, subgraphUrlOverride = SUBGRAPH_URL_BY_CHAIN[chainId]) {
+        this.chainId = chainId;
+        this.retries = retries;
+        this.timeout = timeout;
+        this.rollback = rollback;
+        this.protocol = Protocol.V4;
+        if (!subgraphUrlOverride) {
+            throw new Error(`No subgraph url for chain id: ${chainId}`);
+        }
+        this.client = new GraphQLClient(subgraphUrlOverride);
+    }
+    async getHooks(providerConfig) {
+        const beforeAll = Date.now();
+        let blockNumber = (providerConfig === null || providerConfig === void 0 ? void 0 : providerConfig.blockNumber)
+            ? await providerConfig.blockNumber
+            : undefined;
+        const query = gql `
+      query getEulerSwapHooks($pageSize: Int!, $id: String) {
+        eulerSwapHooks(
+          first: $pageSize,
+          ${blockNumber ? `block: { number: ${blockNumber} }` : ``}
+          where: { id_gt: $id }
+        ) {
+          id
+          hook
+          asset0
+          asset1
+          eulerAccount
+        }
+      }
+    `;
+        let hooks = [];
+        log.info(`Getting hooks from the subgraph with page size ${PAGE_SIZE}${(providerConfig === null || providerConfig === void 0 ? void 0 : providerConfig.blockNumber)
+            ? ` as of block ${providerConfig === null || providerConfig === void 0 ? void 0 : providerConfig.blockNumber}`
+            : ''}.`);
+        let retries = 0;
+        await retry(async () => {
+            const timeout = new Timeout();
+            const getHooks = async () => {
+                let lastId = '';
+                let hooks = [];
+                let hooksPage = [];
+                // metrics variables
+                let totalPages = 0;
+                do {
+                    totalPages += 1;
+                    const hooksResult = await this.client.request(query, {
+                        pageSize: PAGE_SIZE,
+                        id: lastId,
+                    });
+                    hooksPage = hooksResult.eulerSwapHooks;
+                    hooks = hooks.concat(hooksPage);
+                    lastId = hooks[hooks.length - 1].id;
+                    metric.putMetric(`SubgraphProvider.chain_${this.chainId}.getHooks.paginate.pageSize`, hooksPage.length);
+                } while (hooksPage.length > 0);
+                metric.putMetric(`SubgraphProvider.chain_${this.chainId}.getHooks.paginate`, totalPages);
+                metric.putMetric(`SubgraphProvider.chain_${this.chainId}.getHooks.hooks.length`, hooks.length);
+                return hooks;
+            };
+            try {
+                const getHooksPromise = getHooks();
+                const timerPromise = timeout.set(this.timeout).then(() => {
+                    throw new Error(`Timed out getting hooks from subgraph: ${this.timeout}`);
+                });
+                hooks = await Promise.race([getHooksPromise, timerPromise]);
+                return;
+            }
+            catch (err) {
+                log.error({ err }, `Error fetching ${this.protocol} Subgraph Hooks.`);
+                throw err;
+            }
+            finally {
+                timeout.clear();
+            }
+        }, {
+            retries: this.retries,
+            onRetry: (err, retry) => {
+                retries += 1;
+                if (this.rollback &&
+                    blockNumber &&
+                    _.includes(err.message, 'indexed up to')) {
+                    metric.putMetric(`SubgraphProvider.chain_${this.chainId}.getHooks.indexError`, 1);
+                    blockNumber = blockNumber - 10;
+                    log.info(`Detected subgraph indexing error. Rolled back block number to: ${blockNumber}`);
+                }
+                metric.putMetric(`SubgraphProvider.chain_${this.chainId}.getHooks.timeout`, 1);
+                hooks = [];
+                log.info({ err }, `Failed to get hooks from subgraph. Retry attempt: ${retry}`);
+            },
+        });
+        metric.putMetric(`${this.protocol}SubgraphProvider.chain_${this.chainId}.getHooks.retries`, retries);
+        metric.putMetric(`${this.protocol}SubgraphProvider.chain_${this.chainId}.getHooks.latency`, Date.now() - beforeAll);
+        return hooks;
+    }
+    async getPoolByHook(hook, providerConfig) {
+        const beforeAll = Date.now();
+        const blockNumber = (providerConfig === null || providerConfig === void 0 ? void 0 : providerConfig.blockNumber)
+            ? await providerConfig.blockNumber
+            : undefined;
+        const query = gql `
+      query getPools($pageSize: Int!, $hooks: String) {
+        pools(
+          first: $pageSize,
+          ${blockNumber ? `block: { number: ${blockNumber} }` : ``}
+          where: {hooks: $hooks}
+        ) {
+          id
+          token0 {
+            symbol
+            id
+            derivedETH
+          }
+          token1 {
+            symbol
+            id
+            derivedETH
+          }
+          feeTier
+          tick
+          tickSpacing
+          liquidity
+          hooks
+          totalValueLockedUSD
+          totalValueLockedETH
+          totalValueLockedUSDUntracked
+          sqrtPrice
+        }
+      }
+    `;
+        let pool = undefined;
+        log.info(`Getting pool by hook from the subgraph with page size ${PAGE_SIZE}${(providerConfig === null || providerConfig === void 0 ? void 0 : providerConfig.blockNumber)
+            ? ` as of block ${providerConfig === null || providerConfig === void 0 ? void 0 : providerConfig.blockNumber}`
+            : ''}.`);
+        const poolResult = await this.client.request(query, {
+            pageSize: PAGE_SIZE,
+            hooks: hook.toLowerCase(),
+        });
+        pool = poolResult.pools[0];
+        metric.putMetric(`SubgraphProvider.chain_${this.chainId}.getPoolByHook.pools.length`, poolResult.pools.length);
+        metric.putMetric(`${this.protocol}SubgraphProvider.chain_${this.chainId}.getPoolByHook.latency`, Date.now() - beforeAll);
+        return pool;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,58 @@
+import { ChainId, Currency } from '@uniswap/sdk-core';
+import { Pool } from '@uniswap/v4-sdk';
+import { Options as RetryOptions } from 'async-retry';
+import { IMulticallProvider, Result } from '../multicall-provider';
+import { ILiquidity, ISlot0, PoolProvider } from '../pool-provider';
+import { ProviderConfig } from '../provider';
+type V4ISlot0 = ISlot0 & {
+    poolId: string;
+    protocolFee: number;
+    lpFee: number;
+};
+type V4ILiquidity = ILiquidity;
+export interface IV4PoolProvider {
+    getPools(currencyPairs: V4PoolConstruct[], providerConfig?: ProviderConfig): Promise<V4PoolAccessor>;
+    getPoolId(currencyA: Currency, currencyB: Currency, fee: number, tickSpacing: number, hooks: string): {
+        poolId: string;
+        currency0: Currency;
+        currency1: Currency;
+    };
+}
+export type V4PoolAccessor = {
+    getPool: (currencyA: Currency, currencyB: Currency, fee: number, tickSpacing: number, hooks: string) => Pool | undefined;
+    getPoolById: (poolId: string) => Pool | undefined;
+    getAllPools: () => Pool[];
+};
+export type V4PoolRetryOptions = RetryOptions;
+export type V4PoolConstruct = [Currency, Currency, number, number, string];
+export declare function sortsBefore(currencyA: Currency, currencyB: Currency): boolean;
+export declare function isPoolFeeDynamic(tokenA: Currency, tokenB: Currency, tickSpacing: number, hooks: string, poolId: string): boolean;
+export declare class V4PoolProvider extends PoolProvider<Currency, V4PoolConstruct, V4ISlot0, V4ILiquidity, V4PoolAccessor> implements IV4PoolProvider {
+    private POOL_ID_CACHE;
+    /**
+     * Creates an instance of V4PoolProvider.
+     * @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?: V4PoolRetryOptions);
+    getPools(currencyPairs: V4PoolConstruct[], providerConfig?: ProviderConfig): Promise<V4PoolAccessor>;
+    getPoolId(currencyA: Currency, currencyB: Currency, fee: number, tickSpacing: number, hooks: string): {
+        poolId: string;
+        currency0: Currency;
+        currency1: Currency;
+    };
+    protected getLiquidityFunctionName(): string;
+    protected getSlot0FunctionName(): string;
+    protected getPoolsData<TReturn>(poolIds: string[], functionName: string, providerConfig?: ProviderConfig): Promise<Result<TReturn>[]>;
+    protected getPoolIdentifier(pool: V4PoolConstruct): {
+        poolIdentifier: string;
+        currency0: Currency;
+        currency1: Currency;
+    };
+    protected instantiatePool(pool: V4PoolConstruct, slot0: V4ISlot0, liquidity: V4ILiquidity): Pool;
+    protected instantiatePoolAccessor(poolIdentifierToPool: {
+        [p: string]: Pool;
+    }): V4PoolAccessor;
+}
+export {};

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

@@ -0,0 +1,106 @@
+import { DYNAMIC_FEE_FLAG, Pool } from '@uniswap/v4-sdk';
+import retry from 'async-retry';
+import { StateView__factory } from '../../types/other/factories/StateView__factory';
+import { getAddress, log, STATE_VIEW_ADDRESSES } from '../../util';
+import { PoolProvider } from '../pool-provider';
+// TODO: export sortsBefore from v4-sdk https://github.com/Uniswap/sdks/tree/main/sdks/v4-sdk/src/utils to avoid duplication
+export function sortsBefore(currencyA, currencyB) {
+    if (currencyA.isNative)
+        return true;
+    if (currencyB.isNative)
+        return false;
+    return currencyA.wrapped.sortsBefore(currencyB.wrapped);
+}
+export function isPoolFeeDynamic(tokenA, tokenB, tickSpacing, hooks, poolId) {
+    return (Pool.getPoolId(tokenA, tokenB, DYNAMIC_FEE_FLAG, tickSpacing, hooks).toLowerCase() === poolId.toLowerCase());
+}
+export class V4PoolProvider extends PoolProvider {
+    /**
+     * Creates an instance of V4PoolProvider.
+     * @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, multicall2Provider, retryOptions = {
+        retries: 2,
+        minTimeout: 50,
+        maxTimeout: 500,
+    }) {
+        super(chainId, multicall2Provider, retryOptions);
+        // Computing pool id is slow as it requires hashing, encoding etc.
+        // Addresses never change so can always be cached.
+        this.POOL_ID_CACHE = {};
+    }
+    async getPools(currencyPairs, providerConfig) {
+        return await super.getPoolsInternal(currencyPairs, providerConfig);
+    }
+    getPoolId(currencyA, currencyB, fee, tickSpacing, hooks) {
+        const { poolIdentifier, currency0, currency1 } = this.getPoolIdentifier([
+            currencyA,
+            currencyB,
+            fee,
+            tickSpacing,
+            hooks,
+        ]);
+        return { poolId: poolIdentifier, currency0, currency1 };
+    }
+    getLiquidityFunctionName() {
+        return 'getLiquidity';
+    }
+    getSlot0FunctionName() {
+        return 'getSlot0';
+    }
+    async getPoolsData(poolIds, functionName, providerConfig) {
+        const { results, blockNumber } = await retry(async () => {
+            // NOTE: V4 pools are a singleton living under PoolsManager.
+            // We have to retrieve the pool data from the state view contract.
+            // To begin with, we will be consistent with how v4 subgraph retrieves the pool state - via state view.
+            return this.multicall2Provider.callSameFunctionOnContractWithMultipleParams({
+                address: STATE_VIEW_ADDRESSES[this.chainId],
+                contractInterface: StateView__factory.createInterface(),
+                functionName: functionName,
+                functionParams: poolIds.map((poolId) => [poolId]),
+                providerConfig,
+            });
+        }, this.retryOptions);
+        log.debug(`Pool data fetched as of block ${blockNumber}`);
+        return results;
+    }
+    getPoolIdentifier(pool) {
+        const [currencyA, currencyB, fee, tickSpacing, hooks] = pool;
+        const [currency0, currency1] = sortsBefore(currencyA, currencyB)
+            ? [currencyA, currencyB]
+            : [currencyB, currencyA];
+        const currency0Addr = getAddress(currency0);
+        const currency1Addr = getAddress(currency1);
+        const cacheKey = `${this.chainId}/${currency0Addr}/${currency1Addr}/${fee}/${tickSpacing}/${hooks}`;
+        const cachedId = this.POOL_ID_CACHE[cacheKey];
+        if (cachedId) {
+            return { poolIdentifier: cachedId, currency0, currency1 };
+        }
+        const poolId = Pool.getPoolId(currency0, currency1, fee, tickSpacing, hooks);
+        this.POOL_ID_CACHE[cacheKey] = poolId;
+        return { poolIdentifier: poolId, currency0, currency1 };
+    }
+    instantiatePool(pool, slot0, liquidity) {
+        const [currency0, currency1, fee, tickSpacing, hooks] = pool;
+        return new Pool(currency0, currency1, fee, tickSpacing, hooks, slot0.sqrtPriceX96.toString(), liquidity.toString(), slot0.tick);
+    }
+    instantiatePoolAccessor(poolIdentifierToPool) {
+        return {
+            getPool: (currencyA, currencyB, fee, tickSpacing, hooks) => {
+                const { poolIdentifier } = this.getPoolIdentifier([
+                    currencyA,
+                    currencyB,
+                    fee,
+                    tickSpacing,
+                    hooks,
+                ]);
+                return poolIdentifierToPool[poolIdentifier];
+            },
+            getPoolById: (poolId) => poolIdentifierToPool[poolId],
+            getAllPools: () => Object.values(poolIdentifierToPool),
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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