@ring-protocol/smart-order-router 0.5.0

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

@@ -0,0 +1,153 @@
+import { Protocol } from '@ring-protocol/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 '@ring-protocol/sdk-core';
+import { Pool } from '@ring-protocol/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';
+declare type V4ISlot0 = ISlot0 & {
+    poolId: string;
+    protocolFee: number;
+    lpFee: number;
+};
+declare 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 declare type V4PoolAccessor = {
+    getPool: (currencyA: Currency, currencyB: Currency, fee: number, tickSpacing: number, hooks: string) => Pool | undefined;
+    getPoolById: (poolId: string) => Pool | undefined;
+    getAllPools: () => Pool[];
+};
+export declare type V4PoolRetryOptions = RetryOptions;
+export declare 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 '@ring-protocol/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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

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

@@ -0,0 +1,15 @@
+import { ChainId, Currency } from '@ring-protocol/sdk-core';
+import { ProviderConfig } from '../provider';
+import { IV4PoolProvider } from './pool-provider';
+import { IV4SubgraphProvider, V4SubgraphPool } from './subgraph-provider';
+export declare class StaticV4SubgraphProvider implements IV4SubgraphProvider {
+    private chainId;
+    private poolProvider;
+    private v4PoolParams;
+    constructor(chainId: ChainId, poolProvider: IV4PoolProvider, v4PoolParams?: Array<[
+        number,
+        number,
+        string
+    ]>);
+    getPools(currencyIn?: Currency, currencyOut?: Currency, providerConfig?: ProviderConfig): Promise<V4SubgraphPool[]>;
+}

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

@@ -0,0 +1,71 @@
+import { Pool } from '@ring-protocol/v4-sdk';
+import _ from 'lodash';
+import { getAddress, getApplicableV4FeesTickspacingsHooks, log, } from '../../util';
+import { BASES_TO_CHECK_TRADES_AGAINST } from '../caching-subgraph-provider';
+import JSBI from 'jsbi';
+export class StaticV4SubgraphProvider {
+    constructor(chainId, poolProvider, v4PoolParams = getApplicableV4FeesTickspacingsHooks(chainId)) {
+        this.chainId = chainId;
+        this.poolProvider = poolProvider;
+        this.v4PoolParams = v4PoolParams;
+    }
+    async getPools(currencyIn, currencyOut, providerConfig) {
+        log.info('In static subgraph provider for V4');
+        const bases = BASES_TO_CHECK_TRADES_AGAINST[this.chainId];
+        const basePairs = _.flatMap(bases, (base) => bases.map((otherBase) => [base, otherBase]));
+        if (currencyIn && currencyOut) {
+            basePairs.push([currencyIn, currencyOut], ...bases.map((base) => [currencyIn, base]), ...bases.map((base) => [currencyOut, base]));
+        }
+        const pairs = _(basePairs)
+            .filter((tokens) => Boolean(tokens[0] && tokens[1]))
+            .filter(([tokenA, tokenB]) => tokenA.wrapped.address !== tokenB.wrapped.address &&
+            !tokenA.equals(tokenB))
+            .flatMap(([tokenA, tokenB]) => {
+            const tokensWithPoolParams = this.v4PoolParams.map(([feeAmount, tickSpacing, hooks]) => {
+                return [tokenA, tokenB, feeAmount, tickSpacing, hooks];
+            });
+            return tokensWithPoolParams;
+        })
+            .value();
+        log.info(`V4 Static subgraph provider about to get ${pairs.length} pools on-chain`);
+        const poolAccessor = await this.poolProvider.getPools(pairs, providerConfig);
+        const pools = poolAccessor.getAllPools();
+        const poolAddressSet = new Set();
+        const subgraphPools = _(pools)
+            .map((pool) => {
+            const { token0, token1, fee, tickSpacing, hooks, liquidity } = pool;
+            const poolAddress = Pool.getPoolId(token0, token1, fee, tickSpacing, hooks);
+            if (poolAddressSet.has(poolAddress)) {
+                return undefined;
+            }
+            poolAddressSet.add(poolAddress);
+            const liquidityNumber = JSBI.toNumber(liquidity);
+            return {
+                id: poolAddress,
+                feeTier: fee.toString(),
+                tickSpacing: tickSpacing.toString(),
+                hooks: hooks,
+                liquidity: liquidity.toString(),
+                token0: {
+                    symbol: token0.symbol,
+                    id: getAddress(token0),
+                    name: token0.name,
+                    decimals: token0.decimals.toString(),
+                },
+                token1: {
+                    symbol: token1.symbol,
+                    id: getAddress(token1),
+                    name: token1.name,
+                    decimals: token1.decimals.toString(),
+                },
+                // As a very rough proxy we just use liquidity for TVL.
+                tvlETH: liquidityNumber,
+                tvlUSD: liquidityNumber,
+            };
+        })
+            .compact()
+            .value();
+        return subgraphPools;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,5 @@
+import { SubgraphProviderWithFallBacks } from '../subgraph-provider-with-fallback';
+import { IV4SubgraphProvider, V4SubgraphPool } from './subgraph-provider';
+export declare class V4SubgraphProviderWithFallBacks extends SubgraphProviderWithFallBacks<V4SubgraphPool> implements IV4SubgraphProvider {
+    constructor(fallbacks: IV4SubgraphProvider[]);
+}

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

@@ -0,0 +1,8 @@
+import { Protocol } from '@ring-protocol/router-sdk';
+import { SubgraphProviderWithFallBacks } from '../subgraph-provider-with-fallback';
+export class V4SubgraphProviderWithFallBacks extends SubgraphProviderWithFallBacks {
+    constructor(fallbacks) {
+        super(fallbacks, Protocol.V4);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3ViZ3JhcGgtcHJvdmlkZXItd2l0aC1mYWxsYmFjay5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9wcm92aWRlcnMvdjQvc3ViZ3JhcGgtcHJvdmlkZXItd2l0aC1mYWxsYmFjay50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sMkJBQTJCLENBQUM7QUFDckQsT0FBTyxFQUFFLDZCQUE2QixFQUFFLE1BQU0sb0NBQW9DLENBQUM7QUFHbkYsTUFBTSxPQUFPLCtCQUNYLFNBQVEsNkJBQTZDO0lBRXJELFlBQVksU0FBZ0M7UUFDMUMsS0FBSyxDQUFDLFNBQVMsRUFBRSxRQUFRLENBQUMsRUFBRSxDQUFDLENBQUM7SUFDaEMsQ0FBQztDQUNGIn0=

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

@@ -0,0 +1,63 @@
+import { ChainId, Currency } from '@ring-protocol/sdk-core';
+import { ProviderConfig } from '../provider';
+import { SubgraphProvider } from '../subgraph-provider';
+export interface V4SubgraphPool {
+    id: string;
+    feeTier: string;
+    tickSpacing: string;
+    hooks: string;
+    liquidity: string;
+    token0: {
+        symbol?: string;
+        id: string;
+        name?: string;
+        decimals: string;
+    };
+    token1: {
+        symbol?: string;
+        id: string;
+        name?: string;
+        decimals: string;
+    };
+    tvlETH: number;
+    tvlUSD: number;
+}
+export declare type V4RawSubgraphPool = {
+    id: string;
+    feeTier: string;
+    tickSpacing: string;
+    hooks: string;
+    liquidity: string;
+    token0: {
+        symbol: string;
+        id: string;
+        name: string;
+        decimals: string;
+    };
+    token1: {
+        symbol: string;
+        id: string;
+        name: string;
+        decimals: string;
+    };
+    totalValueLockedUSD: string;
+    totalValueLockedETH: string;
+    totalValueLockedUSDUntracked: string;
+};
+export declare const SUBGRAPH_URL_BY_CHAIN: {
+    [chainId in ChainId]?: string;
+};
+/**
+ * Provider for getting V4 pools from the Subgraph
+ *
+ * @export
+ * @interface IV4SubgraphProvider
+ */
+export interface IV4SubgraphProvider {
+    getPools(currencyIn?: Currency, currencyOut?: Currency, providerConfig?: ProviderConfig): Promise<V4SubgraphPool[]>;
+}
+export declare class V4SubgraphProvider extends SubgraphProvider<V4RawSubgraphPool, V4SubgraphPool> implements IV4SubgraphProvider {
+    constructor(chainId: ChainId, retries?: number, timeout?: number, rollback?: boolean, trackedEthThreshold?: number, trackedZoraEthThreshold?: number, zoraHooks?: Set<string>, untrackedUsdThreshold?: number, subgraphUrlOverride?: string, bearerToken?: string);
+    protected mapSubgraphPool(rawPool: V4RawSubgraphPool): V4SubgraphPool;
+    protected getPoolFields(): string;
+}

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

@@ -0,0 +1,59 @@
+import { Protocol } from '@ring-protocol/router-sdk';
+import { ChainId } from '@ring-protocol/sdk-core';
+import { SubgraphProvider } from '../subgraph-provider';
+export const SUBGRAPH_URL_BY_CHAIN = {
+    [ChainId.SEPOLIA]: '',
+};
+export class V4SubgraphProvider extends SubgraphProvider {
+    constructor(chainId, retries = 2, timeout = 30000, rollback = true, trackedEthThreshold = 0.01, trackedZoraEthThreshold = 0.001, zoraHooks = new Set(), untrackedUsdThreshold = Number.MAX_VALUE, subgraphUrlOverride, bearerToken) {
+        super(Protocol.V4, chainId, retries, timeout, rollback, trackedEthThreshold, trackedZoraEthThreshold, zoraHooks, untrackedUsdThreshold, subgraphUrlOverride !== null && subgraphUrlOverride !== void 0 ? subgraphUrlOverride : SUBGRAPH_URL_BY_CHAIN[chainId], bearerToken);
+    }
+    mapSubgraphPool(rawPool) {
+        return {
+            id: rawPool.id,
+            feeTier: rawPool.feeTier,
+            tickSpacing: rawPool.tickSpacing,
+            hooks: rawPool.hooks,
+            liquidity: rawPool.liquidity,
+            token0: {
+                symbol: rawPool.token0.symbol,
+                id: rawPool.token0.id,
+                name: rawPool.token0.name,
+                decimals: rawPool.token0.decimals,
+            },
+            token1: {
+                symbol: rawPool.token1.symbol,
+                id: rawPool.token1.id,
+                name: rawPool.token1.name,
+                decimals: rawPool.token1.decimals,
+            },
+            tvlETH: parseFloat(rawPool.totalValueLockedETH),
+            tvlUSD: parseFloat(rawPool.totalValueLockedUSD),
+        };
+    }
+    // Override to include V4-specific fields
+    getPoolFields() {
+        return `
+      id
+      token0 {
+        symbol
+        id
+        name
+        decimals
+      }
+      token1 {
+        symbol
+        id
+        name
+        decimals
+      }
+      feeTier
+      tickSpacing
+      hooks
+      liquidity
+      totalValueLockedUSD
+      totalValueLockedETH
+    `;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

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

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

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