fix: select pricing pool by liquidity

codex · codex · commit 05c7ae7f5c9e · 2026-07-29T22:38:36.000Z
diff --git a/schema.graphql b/schema.graphql
@@ -69,6 +69,10 @@ type Token @entity(immutable: false) {
   derivedETH: BigDecimal!
   # pools token is in that are white listed for USD pricing
   whitelistPools: [Pool!]!
+  # cached pool with the most native-equivalent liquidity for USD pricing
+  pricingPool: Pool
+  # timestamp of the last full whitelist pool scan
+  pricingPoolLastScanTimestamp: BigInt
   # derived fields
   tokenDayData: [TokenDayData!]! @derivedFrom(field: "token")
 }
@@ -517,4 +521,4 @@ type ArrakisHook @entity(immutable: false) {
   createdAtTimestamp: BigInt!
   # block number of creation
   createdAtBlockNumber: BigInt!
-}
+}
diff --git a/src/mappings/poolManager.ts b/src/mappings/poolManager.ts
@@ -190,13 +190,31 @@ export function handleInitializeHelper(
   if (staticNativePriceUSD.gt(ZERO_BD)) {
     bundle.ethPriceUSD = staticNativePriceUSD
   } else {
-    bundle.ethPriceUSD = getNativePriceInUSD(stablecoinWrappedNativePoolId, stablecoinIsToken0)
+    bundle.ethPriceUSD = getNativePriceInUSD(stablecoinWrappedNativePoolId, stablecoinIsToken0, pool)
   }
   bundle.save()
   updatePoolDayData(pool, event)
   updatePoolHourData(pool, event)
-  token1.derivedETH = findNativePerToken(token1, wrappedNativeAddress, stablecoinAddresses, minimumNativeLocked, bundle)
-  token0.derivedETH = findNativePerToken(token0, wrappedNativeAddress, stablecoinAddresses, minimumNativeLocked, bundle)
+  token1.derivedETH = findNativePerToken(
+    token1,
+    wrappedNativeAddress,
+    stablecoinAddresses,
+    minimumNativeLocked,
+    bundle,
+    event.block.timestamp,
+    pool,
+    token0,
+  )
+  token0.derivedETH = findNativePerToken(
+    token0,
+    wrappedNativeAddress,
+    stablecoinAddresses,
+    minimumNativeLocked,
+    bundle,
+    event.block.timestamp,
+    pool,
+    token1,
+  )
 
   token0.save()
   token1.save()
diff --git a/src/mappings/swap.ts b/src/mappings/swap.ts
@@ -266,7 +266,7 @@ export function handleSwapHelper(event: SwapEvent, subgraphConfig: SubgraphConfi
       const prices = sqrtPriceX96ToTokenPrices(pool.sqrtPrice, token0, token1, nativeTokenDetails)
       pool.token0Price = prices[0]
       pool.token1Price = prices[1]
-      bundle.ethPriceUSD = getNativePriceInUSD(stablecoinWrappedNativePoolId, stablecoinIsToken0)
+      bundle.ethPriceUSD = getNativePriceInUSD(stablecoinWrappedNativePoolId, stablecoinIsToken0, pool)
     }
 
     bundle.save()
@@ -276,13 +276,19 @@ export function handleSwapHelper(event: SwapEvent, subgraphConfig: SubgraphConfi
       stablecoinAddresses,
       minimumNativeLocked,
       bundle,
+      event.block.timestamp,
+      pool,
+      token1,
     )
     token1.derivedETH = findNativePerToken(
       token1,
       wrappedNativeAddress,
       stablecoinAddresses,
       minimumNativeLocked,
       bundle,
+      event.block.timestamp,
+      pool,
+      token0,
     )
 
     /**
diff --git a/src/utils/pricing.ts b/src/utils/pricing.ts
@@ -7,13 +7,7 @@ import { NativeTokenDetails } from './nativeTokenDetails'
 
 const Q192 = BigInt.fromI32(2).pow(192 as u8)
 
-/**
- * Cap how many whitelist pools findNativePerToken will walk. Tokens with long
- * whitelistPools lists otherwise cost O(N) store.gets (Pool + other Token) per
- * call, twice per swap. Prefer the first K entries; pool init appends newest
- * pools at the end so older/larger pools tend to sit earlier.
- */
-const MAX_WHITELIST_POOLS_TO_WALK = 8
+const PRICING_POOL_RESCAN_INTERVAL_SECONDS = BigInt.fromI32(86400)
 
 export function sqrtPriceX96ToTokenPrices(
   sqrtPriceX96: BigInt,
@@ -35,24 +29,65 @@ export function sqrtPriceX96ToTokenPrices(
   return [price0, price1]
 }
 
-export function getNativePriceInUSD(stablecoinWrappedNativePoolId: string, stablecoinIsToken0: boolean): BigDecimal {
+export function getNativePriceInUSD(
+  stablecoinWrappedNativePoolId: string,
+  stablecoinIsToken0: boolean,
+  loadedPool: Pool | null = null,
+): BigDecimal {
   // On chains where the native/reference token is itself a USD stablecoin (e.g. Arc, whose native
   // gas token is USDC and which has no wrapped-native / reference-stable pool), the native price is
   // 1 by definition. Such chains opt in by setting stablecoinWrappedNativePoolId to '' (empty).
   if (stablecoinWrappedNativePoolId == '') {
     return ONE_BD
   }
-  const stablecoinWrappedNativePool = Pool.load(stablecoinWrappedNativePoolId)
+  const stablecoinWrappedNativePool =
+    loadedPool !== null && loadedPool.id == stablecoinWrappedNativePoolId
+      ? loadedPool
+      : Pool.load(stablecoinWrappedNativePoolId)
   if (stablecoinWrappedNativePool !== null) {
     return stablecoinIsToken0 ? stablecoinWrappedNativePool.token0Price : stablecoinWrappedNativePool.token1Price
   } else {
     return ZERO_BD
   }
 }
 
+function getPoolNativeLiquidityAndPrice(token: Token, pool: Pool, loadedReferenceToken: Token | null): BigDecimal[] {
+  if (!pool.liquidity.gt(ZERO_BI)) {
+    return [ZERO_BD, ZERO_BD]
+  }
+
+  let referenceToken = loadedReferenceToken
+  if (pool.token0 == token.id) {
+    if (referenceToken === null || referenceToken.id != pool.token1) {
+      referenceToken = Token.load(pool.token1)
+    }
+    if (referenceToken) {
+      return [
+        pool.totalValueLockedToken1.times(referenceToken.derivedETH),
+        pool.token1Price.times(referenceToken.derivedETH),
+      ]
+    }
+  } else if (pool.token1 == token.id) {
+    if (referenceToken === null || referenceToken.id != pool.token0) {
+      referenceToken = Token.load(pool.token0)
+    }
+    if (referenceToken) {
+      return [
+        pool.totalValueLockedToken0.times(referenceToken.derivedETH),
+        pool.token0Price.times(referenceToken.derivedETH),
+      ]
+    }
+  }
+
+  return [ZERO_BD, ZERO_BD]
+}
+
 /**
  * Search through graph to find derived Eth per token.
  * Callers pass the already-loaded Bundle to avoid a redundant store.get.
+ * The best pool is cached on Token and compared with the active pool on each
+ * call. A periodic full scan repairs stale cache entries and seeds grafted
+ * tokens without assuming whitelistPools creation order reflects liquidity.
  * @todo update to be derived ETH (add stablecoin estimates)
  **/
 export function findNativePerToken(
@@ -61,57 +96,77 @@ export function findNativePerToken(
   stablecoinAddresses: string[],
   minimumNativeLocked: BigDecimal,
   bundle: Bundle,
+  timestamp: BigInt,
+  activePool: Pool | null,
+  activeReferenceToken: Token | null,
 ): BigDecimal {
   if (token.id == wrappedNativeAddress || token.id == ADDRESS_ZERO) {
     return ONE_BD
   }
+  // hardcoded fix for incorrect rates
+  // if whitelist includes token - get the safe price
+  if (stablecoinAddresses.includes(token.id)) {
+    return safeDiv(ONE_BD, bundle.ethPriceUSD)
+  }
+
   const whiteList = token.whitelistPools
-  // for now just take USD from pool with greatest TVL
-  // need to update this to actually detect best rate based on liquidity distribution
+  const cachedPoolId = token.pricingPool
+  const lastScanTimestamp = token.pricingPoolLastScanTimestamp
+  let shouldRescan =
+    lastScanTimestamp === null || timestamp.minus(lastScanTimestamp).ge(PRICING_POOL_RESCAN_INTERVAL_SECONDS)
   let largestLiquidityETH = ZERO_BD
   let priceSoFar = ZERO_BD
+  let bestPoolId: string | null = null
+
+  if (!shouldRescan && cachedPoolId !== null) {
+    const cachedPool = activePool !== null && activePool.id == cachedPoolId ? activePool : Pool.load(cachedPoolId)
+    if (cachedPool !== null) {
+      const loadedReferenceToken = activePool !== null && activePool.id == cachedPoolId ? activeReferenceToken : null
+      const cachedValues = getPoolNativeLiquidityAndPrice(token, cachedPool, loadedReferenceToken)
+      if (cachedValues[0].gt(minimumNativeLocked)) {
+        largestLiquidityETH = cachedValues[0]
+        priceSoFar = cachedValues[1]
+        bestPoolId = cachedPool.id
+      } else {
+        shouldRescan = true
+      }
+    } else {
+      shouldRescan = true
+    }
+  }
 
-  // hardcoded fix for incorrect rates
-  // if whitelist includes token - get the safe price
-  if (stablecoinAddresses.includes(token.id)) {
-    priceSoFar = safeDiv(ONE_BD, bundle.ethPriceUSD)
-  } else {
-    const walkLimit = whiteList.length < MAX_WHITELIST_POOLS_TO_WALK ? whiteList.length : MAX_WHITELIST_POOLS_TO_WALK
-    for (let i = 0; i < walkLimit; ++i) {
+  if (shouldRescan) {
+    largestLiquidityETH = ZERO_BD
+    priceSoFar = ZERO_BD
+    bestPoolId = null
+
+    for (let i = 0; i < whiteList.length; ++i) {
       const poolAddress = whiteList[i]
-      const pool = Pool.load(poolAddress)
-
-      if (pool) {
-        if (pool.liquidity.gt(ZERO_BI)) {
-          if (pool.token0 == token.id) {
-            // whitelist token is token1
-            const token1 = Token.load(pool.token1)
-            // get the derived ETH in pool
-            if (token1) {
-              const ethLocked = pool.totalValueLockedToken1.times(token1.derivedETH)
-              if (ethLocked.gt(largestLiquidityETH) && ethLocked.gt(minimumNativeLocked)) {
-                largestLiquidityETH = ethLocked
-                // token1 per our token * Eth per token1
-                priceSoFar = pool.token1Price.times(token1.derivedETH as BigDecimal)
-              }
-            }
-          }
-          if (pool.token1 == token.id) {
-            const token0 = Token.load(pool.token0)
-            // get the derived ETH in pool
-            if (token0) {
-              const ethLocked = pool.totalValueLockedToken0.times(token0.derivedETH)
-              if (ethLocked.gt(largestLiquidityETH) && ethLocked.gt(minimumNativeLocked)) {
-                largestLiquidityETH = ethLocked
-                // token0 per our token * ETH per token0
-                priceSoFar = pool.token0Price.times(token0.derivedETH as BigDecimal)
-              }
-            }
-          }
+      const pool = activePool !== null && activePool.id == poolAddress ? activePool : Pool.load(poolAddress)
+      if (pool !== null) {
+        const loadedReferenceToken = activePool !== null && activePool.id == poolAddress ? activeReferenceToken : null
+        const values = getPoolNativeLiquidityAndPrice(token, pool, loadedReferenceToken)
+        if (values[0].gt(largestLiquidityETH) && values[0].gt(minimumNativeLocked)) {
+          largestLiquidityETH = values[0]
+          priceSoFar = values[1]
+          bestPoolId = pool.id
         }
       }
     }
+    token.pricingPoolLastScanTimestamp = timestamp
+  } else if (
+    activePool !== null &&
+    (cachedPoolId === null || activePool.id != cachedPoolId) &&
+    whiteList.includes(activePool.id)
+  ) {
+    const values = getPoolNativeLiquidityAndPrice(token, activePool, activeReferenceToken)
+    if (values[0].gt(largestLiquidityETH) && values[0].gt(minimumNativeLocked)) {
+      priceSoFar = values[1]
+      bestPoolId = activePool.id
+    }
   }
+
+  token.pricingPool = bestPoolId
   return priceSoFar
 }
 
diff --git a/tests/handlers/constants.ts b/tests/handlers/constants.ts
@@ -275,6 +275,7 @@ export const createAndStoreTestPool = (poolFixture: PoolFixture): Pool => {
   pool.totalValueLockedUSDUntracked = ZERO_BD
   pool.liquidityProviderCount = ZERO_BI
   pool.hooks = ADDRESS_ZERO
+  pool.isExternalLiquidity = false
 
   pool.save()
   return pool
diff --git a/tests/handlers/handleInitialize.test.ts b/tests/handlers/handleInitialize.test.ts
diff --git a/tests/handlers/handleSwap.test.ts b/tests/handlers/handleSwap.test.ts
