@net-protocol/score 0.1.7 → 0.1.9

package/dist/react.js

@@ -5,6 +5,8 @@ var react = require('react');
 var viem = require('viem');
 var storage = require('@net-protocol/storage');
 var core = require('@net-protocol/core');
+var reactQuery = require('@tanstack/react-query');
+var actions = require('viem/actions');
 
 // src/hooks/useUpvotes.ts
 
@@ -162,6 +164,372 @@ var upvote_app_default = [
   { type: "error", name: "WithdrawFailed", inputs: [] }
 ];
 
+// src/abis/multi-version-uniswap-bulk-pool-finder.json
+var multi_version_uniswap_bulk_pool_finder_default = [
+  {
+    type: "function",
+    name: "V2_FACTORY",
+    inputs: [],
+    outputs: [{ name: "", type: "address", internalType: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "V3_FACTORY",
+    inputs: [],
+    outputs: [{ name: "", type: "address", internalType: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "V4_POOL_MANAGER",
+    inputs: [],
+    outputs: [{ name: "", type: "address", internalType: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "_checkV4PoolExternal",
+    inputs: [
+      {
+        name: "poolKey",
+        type: "tuple",
+        internalType: "struct PoolKey",
+        components: [
+          {
+            name: "currency0",
+            type: "address",
+            internalType: "Currency"
+          },
+          {
+            name: "currency1",
+            type: "address",
+            internalType: "Currency"
+          },
+          { name: "fee", type: "uint24", internalType: "uint24" },
+          { name: "tickSpacing", type: "int24", internalType: "int24" },
+          {
+            name: "hooks",
+            type: "address",
+            internalType: "contract IHooks"
+          }
+        ]
+      }
+    ],
+    outputs: [{ name: "exists", type: "bool", internalType: "bool" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getPoolsMultiVersion",
+    inputs: [
+      {
+        name: "params",
+        type: "tuple",
+        internalType: "struct MultiVersionUniswapBulkPoolFinder.PoolFinderParams",
+        components: [
+          {
+            name: "tokenAs",
+            type: "address[]",
+            internalType: "address[]"
+          },
+          {
+            name: "tokenBs",
+            type: "address[]",
+            internalType: "address[]"
+          },
+          { name: "fees", type: "uint24[]", internalType: "uint24[]" },
+          {
+            name: "v4TickSpacings",
+            type: "int24[]",
+            internalType: "int24[]"
+          },
+          {
+            name: "v4Hooks",
+            type: "address[]",
+            internalType: "address[]"
+          }
+        ]
+      }
+    ],
+    outputs: [
+      {
+        name: "pools",
+        type: "tuple[]",
+        internalType: "struct MultiVersionUniswapBulkPoolFinder.PoolDiscovery[]",
+        components: [
+          {
+            name: "pairIndex",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          { name: "version", type: "uint8", internalType: "uint8" },
+          {
+            name: "poolAddress",
+            type: "address",
+            internalType: "address"
+          },
+          {
+            name: "poolKey",
+            type: "tuple",
+            internalType: "struct PoolKey",
+            components: [
+              {
+                name: "currency0",
+                type: "address",
+                internalType: "Currency"
+              },
+              {
+                name: "currency1",
+                type: "address",
+                internalType: "Currency"
+              },
+              { name: "fee", type: "uint24", internalType: "uint24" },
+              {
+                name: "tickSpacing",
+                type: "int24",
+                internalType: "int24"
+              },
+              {
+                name: "hooks",
+                type: "address",
+                internalType: "contract IHooks"
+              }
+            ]
+          },
+          { name: "fee", type: "uint24", internalType: "uint24" },
+          { name: "tickSpacing", type: "int24", internalType: "int24" },
+          { name: "hooks", type: "address", internalType: "address" }
+        ]
+      },
+      { name: "count", type: "uint256", internalType: "uint256" }
+    ],
+    stateMutability: "view"
+  }
+];
+
+// src/abis/multi-version-uniswap-pool-info-retriever.json
+var multi_version_uniswap_pool_info_retriever_default = [
+  {
+    type: "function",
+    name: "V4_POOL_MANAGER",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "_getV4Liquidity",
+    inputs: [
+      {
+        name: "poolKey",
+        type: "tuple",
+        internalType: "struct PoolKey",
+        components: [
+          {
+            name: "currency0",
+            type: "address",
+            internalType: "Currency"
+          },
+          {
+            name: "currency1",
+            type: "address",
+            internalType: "Currency"
+          },
+          {
+            name: "fee",
+            type: "uint24",
+            internalType: "uint24"
+          },
+          {
+            name: "tickSpacing",
+            type: "int24",
+            internalType: "int24"
+          },
+          {
+            name: "hooks",
+            type: "address",
+            internalType: "contract IHooks"
+          }
+        ]
+      }
+    ],
+    outputs: [
+      {
+        name: "liquidity",
+        type: "uint128",
+        internalType: "uint128"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "_getV4Slot0",
+    inputs: [
+      {
+        name: "poolKey",
+        type: "tuple",
+        internalType: "struct PoolKey",
+        components: [
+          {
+            name: "currency0",
+            type: "address",
+            internalType: "Currency"
+          },
+          {
+            name: "currency1",
+            type: "address",
+            internalType: "Currency"
+          },
+          {
+            name: "fee",
+            type: "uint24",
+            internalType: "uint24"
+          },
+          {
+            name: "tickSpacing",
+            type: "int24",
+            internalType: "int24"
+          },
+          {
+            name: "hooks",
+            type: "address",
+            internalType: "contract IHooks"
+          }
+        ]
+      }
+    ],
+    outputs: [
+      {
+        name: "sqrtPriceX96",
+        type: "uint160",
+        internalType: "uint160"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getPoolsFullInfoMultiVersion",
+    inputs: [
+      {
+        name: "v2PoolAddresses",
+        type: "address[]",
+        internalType: "address[]"
+      },
+      {
+        name: "v3PoolAddresses",
+        type: "address[]",
+        internalType: "address[]"
+      },
+      {
+        name: "v4PoolKeys",
+        type: "tuple[]",
+        internalType: "struct PoolKey[]",
+        components: [
+          {
+            name: "currency0",
+            type: "address",
+            internalType: "Currency"
+          },
+          {
+            name: "currency1",
+            type: "address",
+            internalType: "Currency"
+          },
+          {
+            name: "fee",
+            type: "uint24",
+            internalType: "uint24"
+          },
+          {
+            name: "tickSpacing",
+            type: "int24",
+            internalType: "int24"
+          },
+          {
+            name: "hooks",
+            type: "address",
+            internalType: "contract IHooks"
+          }
+        ]
+      },
+      {
+        name: "baseToken",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "tuple[]",
+        internalType: "struct MultiVersionPoolInfoRetriever.PoolFullInfo[]",
+        components: [
+          {
+            name: "poolAddress",
+            type: "address",
+            internalType: "address"
+          },
+          {
+            name: "token0",
+            type: "address",
+            internalType: "address"
+          },
+          {
+            name: "token1",
+            type: "address",
+            internalType: "address"
+          },
+          {
+            name: "token0Decimals",
+            type: "uint8",
+            internalType: "uint8"
+          },
+          {
+            name: "token1Decimals",
+            type: "uint8",
+            internalType: "uint8"
+          },
+          {
+            name: "sqrtPriceX96",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "baseTokenBalance",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "token0Balance",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "token1Balance",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "liquidity",
+            type: "uint128",
+            internalType: "uint128"
+          }
+        ]
+      }
+    ],
+    stateMutability: "view"
+  }
+];
+
 // src/abis/user-upvote.json
 var user_upvote_default = [
   {
@@ -639,6 +1007,27 @@ var ALL_STRATEGY_ADDRESSES = [
   PURE_ALPHA_STRATEGY.address,
   DYNAMIC_SPLIT_STRATEGY.address
 ];
+var MULTI_VERSION_UNISWAP_BULK_POOL_FINDER = {
+  address: "0xbc237dac4c74c170780fc12f353a258bdd31a8cf",
+  abi: multi_version_uniswap_bulk_pool_finder_default
+};
+var MULTI_VERSION_UNISWAP_POOL_INFO_RETRIEVER = {
+  address: "0x00000002986Ca76897216a8A3A7Db10FcB0d29Cf",
+  abi: multi_version_uniswap_pool_info_retriever_default
+};
+var WETH_BY_CHAIN = {
+  8453: "0x4200000000000000000000000000000000000006",
+  // Base (L2 predeploy)
+  1: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"
+  // Ethereum mainnet
+};
+function getWethAddress(chainId) {
+  const addr = WETH_BY_CHAIN[chainId];
+  if (!addr) {
+    throw new Error(`Score: No WETH address for chain ${chainId}`);
+  }
+  return addr;
+}
 var NULL_ADDRESS = "0x0000000000000000000000000000000000000000";
 var USER_UPVOTE_CONTRACT = {
   address: "0xa4bc2c63dd0157692fd5f409389e5032e37d8895",
@@ -875,10 +1264,365 @@ function useUpvotePrice({
     refetch
   };
 }
+var V3_V4_FEE_TIERS = [500, 3e3, 1e4, 12e3, 8388608];
+var V4_TICK_SPACINGS = [200];
+var V4_HOOKS = [
+  NULL_ADDRESS,
+  "0xDd5EeaFf7BD481AD55Db083062b13a3cdf0A68CC",
+  "0x34a45c6B61876d739400Bd71228CbcbD4F53E8cC",
+  "0xb429d62f8f3bFFb98CdB9569533eA23bF0Ba28CC",
+  "0xd60D6B218116cFd801E28F78d011a203D2b068Cc",
+  "0x3e342a06f9592459D75721d6956B570F02eF2Dc0",
+  "0xbB7784A4d481184283Ed89619A3e3ed143e1Adc0",
+  "0xBDF938149ac6a781F94FAa0ed45E6A0e984c6544"
+];
+var Q96 = BigInt(2) ** BigInt(96);
+var ZERO_BI = BigInt(0);
+function deriveV4WethDepthWei(liquidity, sqrtPriceX96, wethIsCurrency1) {
+  if (sqrtPriceX96 === ZERO_BI || liquidity === ZERO_BI) return ZERO_BI;
+  if (wethIsCurrency1) {
+    return liquidity * sqrtPriceX96 / Q96;
+  }
+  return liquidity * Q96 / sqrtPriceX96;
+}
+function deriveV2V3WethDepthWei(info, wethLower) {
+  if ((info.token0 ?? "").toLowerCase() === wethLower) {
+    return BigInt(info.token0Balance ?? 0);
+  }
+  if ((info.token1 ?? "").toLowerCase() === wethLower) {
+    return BigInt(info.token1Balance ?? 0);
+  }
+  return BigInt(info.baseTokenBalance ?? 0);
+}
+function normalizeTokenPairs(pairs, wethAddress) {
+  return pairs.map((pair) => {
+    const tokenA = pair.tokenAddress;
+    const tokenB = pair.baseTokenAddress || wethAddress;
+    return {
+      originalPair: pair,
+      tokenA: tokenA.toLowerCase() < tokenB.toLowerCase() ? tokenA : tokenB,
+      tokenB: tokenA.toLowerCase() < tokenB.toLowerCase() ? tokenB : tokenA
+    };
+  });
+}
+function buildDiscoveryArgs(normalizedPairs) {
+  return {
+    tokenAs: normalizedPairs.map((p) => p.tokenA),
+    tokenBs: normalizedPairs.map((p) => p.tokenB),
+    fees: V3_V4_FEE_TIERS,
+    v4TickSpacings: V4_TICK_SPACINGS,
+    v4Hooks: V4_HOOKS
+  };
+}
+function parsePoolDiscoveries(poolResults, pairs, wethAddress) {
+  if (!poolResults) {
+    return {
+      v2PoolAddresses: [],
+      v3PoolAddresses: [],
+      v4PoolKeys: [],
+      v2PoolAddressToPair: {},
+      v3PoolAddressToPair: {},
+      v4PoolKeyToPair: {}
+    };
+  }
+  const [discoveries, countRaw] = poolResults;
+  const countNum = typeof countRaw === "bigint" ? Number(countRaw) : Number(countRaw || 0);
+  const v2PoolAddresses = [];
+  const v3PoolAddresses = [];
+  const v4PoolKeys = [];
+  const seenV2V3Addresses = /* @__PURE__ */ new Set();
+  const seenV4Keys = /* @__PURE__ */ new Set();
+  const v2PoolAddressToPair = {};
+  const v3PoolAddressToPair = {};
+  const v4PoolKeyToPair = {};
+  for (let i = 0; i < Math.min(countNum, discoveries.length); i++) {
+    const discovery = discoveries[i];
+    const version = Number(discovery?.version ?? 0);
+    const poolAddressValue = discovery?.poolAddress;
+    const pairIndex = Number(discovery?.pairIndex ?? 0);
+    const feeNum = Number(discovery?.fee ?? 0);
+    const poolKey = discovery?.poolKey;
+    const pair = pairs[pairIndex];
+    if (!pair) continue;
+    if (version === 2 && poolAddressValue && poolAddressValue !== NULL_ADDRESS) {
+      const poolAddress = poolAddressValue.toLowerCase();
+      if (!seenV2V3Addresses.has(poolAddress)) {
+        seenV2V3Addresses.add(poolAddress);
+        v2PoolAddresses.push(poolAddressValue);
+        v2PoolAddressToPair[poolAddress] = {
+          tokenAddress: pair.tokenAddress,
+          baseTokenAddress: pair.baseTokenAddress || wethAddress,
+          fee: feeNum
+        };
+      }
+    } else if (version === 3 && poolAddressValue && poolAddressValue !== NULL_ADDRESS) {
+      const poolAddress = poolAddressValue.toLowerCase();
+      if (!seenV2V3Addresses.has(poolAddress)) {
+        seenV2V3Addresses.add(poolAddress);
+        v3PoolAddresses.push(poolAddressValue);
+        v3PoolAddressToPair[poolAddress] = {
+          tokenAddress: pair.tokenAddress,
+          baseTokenAddress: pair.baseTokenAddress || wethAddress,
+          fee: feeNum
+        };
+      }
+    } else if (version === 4 && poolKey) {
+      const poolKeyString = JSON.stringify(poolKey);
+      if (!seenV4Keys.has(poolKeyString)) {
+        seenV4Keys.add(poolKeyString);
+        v4PoolKeys.push(poolKey);
+        v4PoolKeyToPair[poolKeyString] = {
+          tokenAddress: pair.tokenAddress,
+          baseTokenAddress: pair.baseTokenAddress || wethAddress,
+          fee: feeNum
+        };
+      }
+    }
+  }
+  return {
+    v2PoolAddresses,
+    v3PoolAddresses,
+    v4PoolKeys,
+    v2PoolAddressToPair,
+    v3PoolAddressToPair,
+    v4PoolKeyToPair
+  };
+}
+function determinePoolVersion(discoveries, index) {
+  const {
+    v2PoolAddresses,
+    v3PoolAddresses,
+    v4PoolKeys,
+    v2PoolAddressToPair,
+    v3PoolAddressToPair,
+    v4PoolKeyToPair
+  } = discoveries;
+  if (index < v2PoolAddresses.length) {
+    const poolAddress = v2PoolAddresses[index].toLowerCase();
+    return {
+      version: 2,
+      pair: v2PoolAddressToPair[poolAddress],
+      fee: 0,
+      v4PoolKey: void 0
+    };
+  } else if (index < v2PoolAddresses.length + v3PoolAddresses.length) {
+    const v3Index = index - v2PoolAddresses.length;
+    const poolAddress = v3PoolAddresses[v3Index].toLowerCase();
+    return {
+      version: 3,
+      pair: v3PoolAddressToPair[poolAddress],
+      fee: v3PoolAddressToPair[poolAddress]?.fee || 0,
+      v4PoolKey: void 0
+    };
+  } else {
+    const v4Index = index - v2PoolAddresses.length - v3PoolAddresses.length;
+    const poolKey = v4PoolKeys[v4Index];
+    const poolKeyString = JSON.stringify(poolKey);
+    return {
+      version: 4,
+      pair: v4PoolKeyToPair[poolKeyString],
+      fee: v4PoolKeyToPair[poolKeyString]?.fee || 0,
+      v4PoolKey: poolKey
+    };
+  }
+}
+function calculatePoolPrice(info, pair, version) {
+  try {
+    const sqrtPriceX96 = Number(info.sqrtPriceX96);
+    const token0Decimals = Number(info.token0Decimals);
+    const token1Decimals = Number(info.token1Decimals);
+    const isToken0 = info.token0.toLowerCase() === pair.tokenAddress.toLowerCase();
+    if (version === 2) {
+      const token0Balance = Number(info.token0Balance) / 10 ** token0Decimals;
+      const token1Balance = Number(info.token1Balance) / 10 ** token1Decimals;
+      if (token0Balance === 0 || token1Balance === 0) return null;
+      if (isToken0) {
+        return token1Balance / token0Balance;
+      } else {
+        return token0Balance / token1Balance;
+      }
+    } else {
+      if (sqrtPriceX96 === 0) return null;
+      if (isToken0) {
+        return (sqrtPriceX96 / 2 ** 96) ** 2 * 10 ** (token0Decimals - token1Decimals);
+      } else {
+        const priceX96 = (sqrtPriceX96 / 2 ** 96) ** 2;
+        return 1 / priceX96 * 10 ** (token1Decimals - token0Decimals);
+      }
+    }
+  } catch {
+    return null;
+  }
+}
+function constructPoolKey(info, pair, version, v4PoolKey) {
+  try {
+    if (!info.token0 || !info.token1 || typeof pair.fee !== "number") {
+      return void 0;
+    }
+    if (!info.token0.startsWith("0x") || !info.token1.startsWith("0x")) {
+      return void 0;
+    }
+    const currency0 = info.token0.toLowerCase() < info.token1.toLowerCase() ? info.token0 : info.token1;
+    const currency1 = info.token0.toLowerCase() < info.token1.toLowerCase() ? info.token1 : info.token0;
+    if (version === 2) {
+      return {
+        currency0,
+        currency1,
+        fee: 0,
+        tickSpacing: 0,
+        hooks: NULL_ADDRESS
+      };
+    } else if (version === 3) {
+      return {
+        currency0,
+        currency1,
+        fee: pair.fee,
+        tickSpacing: 0,
+        hooks: NULL_ADDRESS
+      };
+    } else {
+      if (!v4PoolKey || !v4PoolKey.currency0 || !v4PoolKey.currency1) {
+        return void 0;
+      }
+      return v4PoolKey;
+    }
+  } catch {
+    return void 0;
+  }
+}
+function selectBestPoolPerPair(allPools) {
+  const poolsByPair = {};
+  for (const pool of allPools) {
+    const key = pool.tokenAddress.toLowerCase() + "_" + pool.baseTokenAddress.toLowerCase();
+    if (!poolsByPair[key]) poolsByPair[key] = [];
+    poolsByPair[key].push(pool);
+  }
+  const bestPools = [];
+  for (const group of Object.values(poolsByPair)) {
+    const withDepth = group.filter((p) => p.wethDepthWei > ZERO_BI);
+    if (withDepth.length === 0) continue;
+    const best = withDepth.reduce(
+      (a, b) => a.wethDepthWei > b.wethDepthWei ? a : b
+    );
+    bestPools.push(best);
+  }
+  return bestPools;
+}
+async function discoverPools({
+  publicClient,
+  pairs,
+  chainId = 8453
+}) {
+  if (pairs.length === 0) return [];
+  const wethAddress = getWethAddress(chainId);
+  const normalizedPairs = normalizeTokenPairs(pairs, wethAddress);
+  const discoveryArgs = buildDiscoveryArgs(normalizedPairs);
+  const poolResults = await actions.readContract(publicClient, {
+    address: MULTI_VERSION_UNISWAP_BULK_POOL_FINDER.address,
+    abi: MULTI_VERSION_UNISWAP_BULK_POOL_FINDER.abi,
+    functionName: "getPoolsMultiVersion",
+    args: [discoveryArgs]
+  });
+  const discoveries = parsePoolDiscoveries(poolResults, pairs, wethAddress);
+  const totalPools = discoveries.v2PoolAddresses.length + discoveries.v3PoolAddresses.length + discoveries.v4PoolKeys.length;
+  if (totalPools === 0) return [];
+  const poolInfos = await actions.readContract(publicClient, {
+    address: MULTI_VERSION_UNISWAP_POOL_INFO_RETRIEVER.address,
+    abi: MULTI_VERSION_UNISWAP_POOL_INFO_RETRIEVER.abi,
+    functionName: "getPoolsFullInfoMultiVersion",
+    args: [
+      discoveries.v2PoolAddresses,
+      discoveries.v3PoolAddresses,
+      discoveries.v4PoolKeys,
+      wethAddress
+    ]
+  });
+  if (!Array.isArray(poolInfos) || poolInfos.length === 0) return [];
+  const wethLower = wethAddress.toLowerCase();
+  const allPools = poolInfos.map((info, index) => {
+    const poolData = determinePoolVersion(discoveries, index);
+    if (!poolData || !poolData.pair) return null;
+    const isV4 = poolData.version === 4;
+    const liquidity = BigInt(info.liquidity ?? 0);
+    let wethDepthWei;
+    if (isV4) {
+      const wethIsCurrency1 = poolData.v4PoolKey.currency1.toLowerCase() === wethLower;
+      wethDepthWei = deriveV4WethDepthWei(
+        liquidity,
+        BigInt(info.sqrtPriceX96 ?? 0),
+        wethIsCurrency1
+      );
+    } else {
+      wethDepthWei = deriveV2V3WethDepthWei(info, wethLower);
+    }
+    return {
+      tokenAddress: poolData.pair.tokenAddress,
+      baseTokenAddress: poolData.pair.baseTokenAddress || wethAddress,
+      poolAddress: isV4 ? null : info.poolAddress,
+      price: calculatePoolPrice(info, poolData.pair, poolData.version),
+      baseTokenBalance: String(info.baseTokenBalance || 0),
+      token0: info.token0,
+      token1: info.token1,
+      token0Balance: String(info.token0Balance || 0),
+      token1Balance: String(info.token1Balance || 0),
+      fee: poolData.fee,
+      poolKey: constructPoolKey(
+        info,
+        poolData.pair,
+        poolData.version,
+        poolData.v4PoolKey
+      ),
+      liquidity: String(liquidity),
+      wethDepthWei
+    };
+  }).filter((p) => p !== null);
+  const bestPools = selectBestPoolPerPair(allPools);
+  return bestPools.map(
+    (pool) => ({
+      tokenAddress: pool.tokenAddress,
+      baseTokenAddress: pool.baseTokenAddress,
+      poolAddress: pool.poolAddress,
+      price: pool.price,
+      fee: pool.fee,
+      poolKey: pool.poolKey,
+      liquidity: pool.liquidity,
+      balances: {
+        baseTokenBalance: pool.baseTokenBalance,
+        token0Balance: pool.token0Balance,
+        token1Balance: pool.token1Balance
+      }
+    })
+  );
+}
+
+// src/hooks/useDiscoverPools.ts
+function useDiscoverPools({
+  chainId,
+  pairs,
+  enabled = true
+}) {
+  const publicClient = wagmi.usePublicClient({ chainId });
+  const canRun = enabled && !!publicClient && pairs.length > 0;
+  const keyPairs = pairs.map((p) => [
+    p.tokenAddress.toLowerCase(),
+    p.baseTokenAddress?.toLowerCase()
+  ]);
+  const { data, isLoading, error, refetch } = reactQuery.useQuery({
+    queryKey: ["discoverPools", chainId, keyPairs],
+    queryFn: canRun ? () => discoverPools({ publicClient, pairs, chainId }) : reactQuery.skipToken
+  });
+  return {
+    pools: data ?? [],
+    isLoading,
+    error,
+    refetch
+  };
+}
 
 exports.getScoreKey = getScoreKey;
 exports.getStorageScoreKey = getStorageScoreKey;
 exports.getTokenScoreKey = getTokenScoreKey;
+exports.useDiscoverPools = useDiscoverPools;
 exports.useTokenUpvotes = useTokenUpvotes;
 exports.useUpvotePrice = useUpvotePrice;
 exports.useUpvoteUser = useUpvoteUser;