@net-protocol/score 0.1.0 → 0.1.1

package/dist/index.js

@@ -1657,6 +1657,283 @@ var dynamic_split_strategy_default = [
   }
 ];
 
+// 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: "_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"
+          }
+        ]
+      }
+    ],
+    stateMutability: "view"
+  }
+];
+
 // src/constants.ts
 var SCORE_CONTRACT = {
   address: "0x0000000fa09b022e5616e5a173b4b67fa2fbcf28",
@@ -1690,6 +1967,17 @@ var ALL_STRATEGY_ADDRESSES = [
 var LEGACY_UPVOTE_V1_ADDRESS = "0x0ada882dbbdc12388a1f9ca85d2d847088f747df";
 var LEGACY_UPVOTE_V2_ADDRESS = "0x9027dcad0a3dca5835895e14fbc022a1e5ea909b";
 var SUPPORTED_SCORE_CHAINS = [8453];
+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: "0x7A9EF0AC6F6a254cd570B05D62D094D3aa5067f1",
+  abi: multi_version_uniswap_pool_info_retriever_default
+};
+var WETH_ADDRESS = "0x4200000000000000000000000000000000000006";
+var NULL_ADDRESS = "0x0000000000000000000000000000000000000000";
+var UPVOTE_PRICE_ETH = 25e-6;
 var encodeUpvoteKey = (tokenAddress) => {
   return `0x${BigInt(`0x${tokenAddress.slice(2)}`).toString(16).padStart(64, "0")}`;
 };
@@ -2116,21 +2404,400 @@ var encodePoolKey = (poolKey) => {
 function isValidPoolKey2(poolKey) {
   return poolKey.fee !== void 0 || poolKey.tickSpacing !== void 0 || poolKey.currency0 !== void 0;
 }
+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"
+];
+var LIQUIDITY_THRESHOLD_TO_PREFER_V2_V3_POOLS = 0.1 * 1e18;
+var LIQUIDITY_THRESHOLD_TO_CONSIDER_V2_V3_POOLS = 0.01 * 1e18;
+function normalizeTokenPairs(pairs) {
+  return pairs.map((pair) => {
+    const tokenA = pair.tokenAddress;
+    const tokenB = pair.baseTokenAddress || WETH_ADDRESS;
+    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) {
+  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 || WETH_ADDRESS,
+          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 || WETH_ADDRESS,
+          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 || WETH_ADDRESS,
+          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 calculatePriceFromSqrtPriceX96(sqrtPriceX96, token0Decimals, token1Decimals, isToken0) {
+  const sqrtPrice = Number(sqrtPriceX96);
+  if (sqrtPrice === 0) return 0;
+  const priceX96 = (sqrtPrice / 2 ** 96) ** 2;
+  if (isToken0) {
+    return priceX96 * 10 ** (token0Decimals - token1Decimals);
+  } else {
+    return 1 / priceX96 * 10 ** (token1Decimals - token0Decimals);
+  }
+}
+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 getWethBalanceWei(pool) {
+  if (pool.token0?.toLowerCase() === WETH_ADDRESS.toLowerCase()) {
+    return Number(pool.token0Balance);
+  } else if (pool.token1?.toLowerCase() === WETH_ADDRESS.toLowerCase()) {
+    return Number(pool.token1Balance);
+  } else {
+    return Number(pool.baseTokenBalance);
+  }
+}
+function filterV2V3PoolsByLiquidity(pools, threshold) {
+  return pools.filter((pool) => {
+    if (!pool.poolAddress) return false;
+    const wethBalanceWei = getWethBalanceWei(pool);
+    return wethBalanceWei >= threshold;
+  });
+}
+function selectBestV2V3Pool(pools) {
+  return pools.reduce((a, b) => {
+    const aIsV3 = a.fee > 0;
+    const bIsV3 = b.fee > 0;
+    if (aIsV3 && !bIsV3) return a;
+    if (!aIsV3 && bIsV3) return b;
+    return Number(a.baseTokenBalance) > Number(b.baseTokenBalance) ? a : b;
+  });
+}
+function selectBestV4Pool(pools) {
+  return pools.reduce((a, b) => {
+    return a.fee < b.fee ? a : b;
+  });
+}
+function selectBestV2V3PoolByFee(pools) {
+  return pools.reduce((a, b) => {
+    return a.fee < b.fee ? a : b;
+  });
+}
+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.entries(poolsByPair)) {
+    let best;
+    if (group.length === 1) {
+      best = group[0];
+    } else {
+      const v2v3PoolsWithPreferredLiquidity = filterV2V3PoolsByLiquidity(
+        group,
+        LIQUIDITY_THRESHOLD_TO_PREFER_V2_V3_POOLS
+      );
+      if (v2v3PoolsWithPreferredLiquidity.length > 0) {
+        best = selectBestV2V3Pool(v2v3PoolsWithPreferredLiquidity);
+      } else {
+        const v4Pools = group.filter((pool) => !pool.poolAddress);
+        if (v4Pools.length > 0) {
+          best = selectBestV4Pool(v4Pools);
+        } else {
+          const v2v3PoolsWithAcceptableLiquidity = filterV2V3PoolsByLiquidity(
+            group,
+            LIQUIDITY_THRESHOLD_TO_CONSIDER_V2_V3_POOLS
+          );
+          if (v2v3PoolsWithAcceptableLiquidity.length > 0) {
+            best = selectBestV2V3PoolByFee(v2v3PoolsWithAcceptableLiquidity);
+          }
+        }
+      }
+    }
+    if (best) {
+      bestPools.push(best);
+    }
+  }
+  return bestPools;
+}
+async function discoverPools({
+  publicClient,
+  pairs
+}) {
+  if (pairs.length === 0) return [];
+  const normalizedPairs = normalizeTokenPairs(pairs);
+  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);
+  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,
+      WETH_ADDRESS
+    ]
+  });
+  if (!Array.isArray(poolInfos) || poolInfos.length === 0) return [];
+  const allPools = poolInfos.map((info, index) => {
+    const poolData = determinePoolVersion(discoveries, index);
+    if (!poolData || !poolData.pair) return null;
+    return {
+      tokenAddress: poolData.pair.tokenAddress,
+      baseTokenAddress: poolData.pair.baseTokenAddress || WETH_ADDRESS,
+      poolAddress: poolData.version === 4 ? 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
+      )
+    };
+  }).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,
+      balances: {
+        baseTokenBalance: pool.baseTokenBalance,
+        token0Balance: pool.token0Balance,
+        token1Balance: pool.token1Balance
+      }
+    })
+  );
+}
+async function discoverTokenPool({
+  publicClient,
+  tokenAddress
+}) {
+  const results = await discoverPools({
+    publicClient,
+    pairs: [{ tokenAddress }]
+  });
+  return results[0] ?? null;
+}
 
 exports.ALL_STRATEGY_ADDRESSES = ALL_STRATEGY_ADDRESSES;
 exports.DYNAMIC_SPLIT_STRATEGY = DYNAMIC_SPLIT_STRATEGY;
 exports.LEGACY_UPVOTE_V1_ADDRESS = LEGACY_UPVOTE_V1_ADDRESS;
 exports.LEGACY_UPVOTE_V2_ADDRESS = LEGACY_UPVOTE_V2_ADDRESS;
+exports.MULTI_VERSION_UNISWAP_BULK_POOL_FINDER = MULTI_VERSION_UNISWAP_BULK_POOL_FINDER;
+exports.MULTI_VERSION_UNISWAP_POOL_INFO_RETRIEVER = MULTI_VERSION_UNISWAP_POOL_INFO_RETRIEVER;
+exports.NULL_ADDRESS = NULL_ADDRESS;
 exports.PURE_ALPHA_STRATEGY = PURE_ALPHA_STRATEGY;
 exports.SCORE_CONTRACT = SCORE_CONTRACT;
 exports.SUPPORTED_SCORE_CHAINS = SUPPORTED_SCORE_CHAINS;
 exports.ScoreClient = ScoreClient;
 exports.UNIV234_POOLS_STRATEGY = UNIV234_POOLS_STRATEGY;
 exports.UPVOTE_APP = UPVOTE_APP;
+exports.UPVOTE_PRICE_ETH = UPVOTE_PRICE_ETH;
 exports.UPVOTE_STORAGE_APP = UPVOTE_STORAGE_APP;
+exports.WETH_ADDRESS = WETH_ADDRESS;
+exports.calculatePriceFromSqrtPriceX96 = calculatePriceFromSqrtPriceX96;
 exports.decodeStrategyMetadata = decodeStrategyMetadata;
 exports.decodeUpvoteMessage = decodeUpvoteMessage;
 exports.decodeUpvoteStorageBlob = decodeUpvoteStorageBlob;
+exports.discoverPools = discoverPools;
+exports.discoverTokenPool = discoverTokenPool;
 exports.encodePoolKey = encodePoolKey;
 exports.encodeUpvoteKey = encodeUpvoteKey;
 exports.extractStrategyAddress = extractStrategyAddress;