@stake-dao/reader 0.5.14 → 0.5.16

package/src/prices.ts

@@ -1,7 +1,9 @@
-import { tokenWithId } from '@stake-dao/constants'
-import { chunk, uniq } from 'lodash-es'
+import { RPC, tokenWithId, tokens } from '@stake-dao/constants'
+import { chunk, uniq, uniqWith } from 'lodash-es'
+import { decodeAbiParameters, formatUnits } from 'viem'
+import { mainnet } from 'viem/chains'
 import { TOKENS_CHUNK_SIZE } from './strategies/curve/fetch/curveApiData/config.js'
-import { equalTlc } from './utils.js'
+import { equalTlc, rpcCall } from './utils.js'
 
 const LLAMA_API_URL = 'https://coins.llama.fi'
 const GECKO_TERMINAL_API_URL = 'https://api.geckoterminal.com/api/v2'
@@ -12,41 +14,127 @@ export type Price = {
   usdPrice: number
 }
 
+interface TokenToFetch {
+  address: string
+  symbol: string
+  extensions?: {
+    onChainPrice?: {
+      to: string
+      data: string
+      decimals: number
+    }
+  }
+}
+
+interface TokenToFetchWithChainId extends TokenToFetch {
+  chainId: number
+}
+
+const FORCE_GECKO_TERMINAL_TOKENS = {
+  [mainnet.id]: [],
+}
+
+// ********************************************************************************
+// ********                                                                ********
+// ********                     DEFILLAMA CHAIN PREFIX                     ********
+// ********                                                                ********
+// ********************************************************************************
+
 export const getLlamaTokenPrefix = (chainId = 1): string => {
-  switch (chainId) {
-    case 1:
-      return 'ethereum'
-    case 10:
-      return 'optimism'
-    case 56:
-      return 'bsc'
-    case 137:
-      return 'polygon'
-    case 146:
-      return 'sonic'
-    case 252:
-      return 'fraxtal'
-    case 999:
-      return 'hyperliquid'
-    case 8453:
-      return 'base'
-    case 42161:
-      return 'arbitrum'
-    case 43114:
-      return 'avax'
-    case 59144:
-      return 'linea'
-    case 42793:
-      return 'etherlink'
-    default:
-      return 'ethereum'
+  if (chainId === 1) return 'ethereum'
+  if (chainId === 10) return 'optimism'
+  if (chainId === 56) return 'bsc'
+  if (chainId === 137) return 'polygon'
+  if (chainId === 146) return 'sonic'
+  if (chainId === 252) return 'fraxtal'
+  if (chainId === 999) return 'hyperliquid'
+  if (chainId === 8453) return 'base'
+  if (chainId === 42161) return 'arbitrum'
+  if (chainId === 43114) return 'avax'
+  if (chainId === 59144) return 'linea'
+  if (chainId === 42793) return 'etherlink'
+
+  return 'ethereum'
+}
+
+// ********************************************************************************
+// ********                                                                ********
+// ********                   GECKO TERMINAL CHAIN PREFIX                  ********
+// ********                                                                ********
+// ********************************************************************************
+
+export const getGeckoTerminalTokenPrefix = (chainId = 1): string => {
+  if (chainId === 1) return 'eth'
+  if (chainId === 10) return 'optimism'
+  if (chainId === 56) return 'bsc'
+  if (chainId === 137) return 'polygon_pos'
+  if (chainId === 146) return 'sonic'
+  if (chainId === 252) return 'fraxtal'
+  if (chainId === 999) return 'hyperliquid'
+  if (chainId === 8453) return 'base'
+  if (chainId === 42161) return 'arbitrum'
+  if (chainId === 43114) return 'avax'
+  if (chainId === 59144) return 'linea'
+  if (chainId === 42793) return 'etherlink'
+
+  return 'eth'
+}
+
+// ********************************************************************************
+// ********                                                                ********
+// ********                            ON CHAIN                            ********
+// ********                                                                ********
+// ********************************************************************************
+
+export const getOnChainPrices = async (tokens: TokenToFetch[]): Promise<Price[]> => {
+  try {
+    const tokenWithOnChainPrice = tokens.filter((t) => t.extensions?.onChainPrice)
+    if (tokenWithOnChainPrice.length === 0) return []
+
+    const uniqCalls = uniqWith(
+      tokenWithOnChainPrice.map((t) => t.extensions!.onChainPrice!),
+      (a, b) => {
+        return equalTlc(a.to, b.to) && equalTlc(a.data, b.data) && a.decimals === b.decimals
+      },
+    )
+    const rawPrices = await rpcCall(RPC[mainnet.id], uniqCalls)
+    const prices: Price[] = []
+
+    for (let i = 0; i < rawPrices.length; i++) {
+      const call = uniqCalls[i]!
+      const tokensToPrice = tokenWithOnChainPrice.filter((t) => equalTlc(t.extensions!.onChainPrice!.to, call.to))
+      const decodedRes = decodeAbiParameters([{ type: 'int256' }], rawPrices[i].result)[0]
+
+      for (const t of tokensToPrice) {
+        prices.push({
+          symbol: t.symbol,
+          address: t.address,
+          usdPrice: Number(formatUnits(decodedRes, call.decimals)),
+        })
+      }
+    }
+
+    return prices
+  } catch (e) {
+    console.error(e)
+    return []
   }
 }
 
-export const getPricesFromLlama = async (tokens: any[], chainId = 1, defaultErrorValue?: any): Promise<Price[]> => {
+// ********************************************************************************
+// ********                                                                ********
+// ********                           DEFILLAMA                            ********
+// ********                                                                ********
+// ********************************************************************************
+
+export const getPricesFromLlama = async (
+  tokens: TokenToFetch[],
+  chainId: number = mainnet.id,
+  defaultErrorValue?: any,
+): Promise<Price[]> => {
   if (tokens.length > 0) {
     try {
-      const parsedPrice: { symbol: string; address: string; usdPrice: number }[] = []
+      const parsedPrice: Price[] = []
 
       const prefix: string = getLlamaTokenPrefix(chainId)
       const tokensChunks = chunk(tokens, TOKENS_CHUNK_SIZE)
@@ -77,47 +165,15 @@ export const getPricesFromLlama = async (tokens: any[], chainId = 1, defaultErro
   return []
 }
 
-export const getPricesFromCurve = async (chainId: number) => {
-  const prefix = getLlamaTokenPrefix(chainId)
-  const httpRequest = (await fetch(`https://prices.curve.finance/v1/usd_price/${prefix}`)).json()
-
-  return httpRequest
-}
-
-export const getGeckoTerminalTokenPrefix = (chainId = 1): string => {
-  switch (chainId) {
-    case 1:
-      return 'eth'
-    case 10:
-      return 'optimism'
-    case 56:
-      return 'bsc'
-    case 137:
-      return 'polygon_pos'
-    case 146:
-      return 'sonic'
-    case 252:
-      return 'fraxtal'
-    case 999:
-      return 'hyperliquid'
-    case 8453:
-      return 'base'
-    case 42161:
-      return 'arbitrum'
-    case 43114:
-      return 'avax'
-    case 59144:
-      return 'linea'
-    case 42793:
-      return 'etherlink'
-    default:
-      return 'eth'
-  }
-}
+// ********************************************************************************
+// ********                                                                ********
+// ********                         GECKO TERMINAL                         ********
+// ********                                                                ********
+// ********************************************************************************
 
 export const getPricesFromGeckoTerminal = async (
-  tokens: any[],
-  chainId = 1,
+  tokens: TokenToFetch[],
+  chainId: number = mainnet.id,
   defaultErrorValue?: any,
 ): Promise<Price[]> => {
   try {
@@ -149,41 +205,99 @@ export const getPricesFromGeckoTerminal = async (
   }
 }
 
-interface TokenToFetch {
-  address: string
-  symbol: string
+// ********************************************************************************
+// ********                                                                ********
+// ********                           CURVE API                            ********
+// ********                                                                ********
+// ********************************************************************************
+
+export const getPricesFromCurve = async (chainId: number) => {
+  const prefix = getLlamaTokenPrefix(chainId)
+  const httpRequest = (await fetch(`https://prices.curve.finance/v1/usd_price/${prefix}`)).json()
+
+  return httpRequest
 }
 
+// ********************************************************************************
+// ********                                                                ********
+// ********                        GLOBAL PER CHAIN                        ********
+// ********                                                                ********
+// ********************************************************************************
+
 export const getPrices = async (tokens: TokenToFetch[], chainId = 1): Promise<Price[]> => {
-  let pricesFromGecko: Price[] = []
-  if (tokens.length > 0) {
-    pricesFromGecko = pricesFromGecko.concat(await getPricesFromGeckoTerminal(tokens, chainId))
-  }
+  // Fetch on chain first
+  let res: Price[] = await getOnChainPrices(tokens)
 
-  const pricesToFetchFromLlama = tokens
-    .map((t) => {
-      const coinPrice = pricesFromGecko.find((pl) => equalTlc(pl.address, t.address))?.usdPrice || 0
-      return coinPrice === 0 ? t : undefined
-    })
-    .filter(Boolean)
+  const toFetchFromGecko = tokens
+    .map((t) => ({ ...t, usdPrice: res.find((r) => equalTlc(r.address, t.address))?.usdPrice || 0 }))
+    .filter((t) => t.usdPrice === 0)
 
-  let pricesFromLlama: Price[] = []
-  if (tokens.length > 0) {
-    pricesFromLlama = pricesFromLlama.concat(await getPricesFromLlama(pricesToFetchFromLlama, chainId))
-  }
+  if (toFetchFromGecko.length > 0) res = res.concat(await getPricesFromGeckoTerminal(toFetchFromGecko, chainId))
+
+  const toFetchFromLlama = tokens
+    .map((t) => ({ ...t, usdPrice: res.find((r) => equalTlc(r.address, t.address))?.usdPrice || 0 }))
+    .filter((t) => t.usdPrice === 0)
 
-  const prices = [pricesFromLlama, pricesFromGecko].flat().filter((p) => p.usdPrice > 0)
+  if (toFetchFromLlama.length > 0) res = res.concat(await getPricesFromLlama(toFetchFromLlama, chainId))
 
   // Use WBTC price for WBTC18
-  const wbtc = prices.find((p) => equalTlc(p.address, tokenWithId('wbtc', 1)?.address!))
+  const wbtc = res.find((p) => equalTlc(p.address, tokenWithId('wbtc', 1)?.address!))
   if (wbtc) {
     const wbtc18 = tokenWithId('wbtc18', 1)!
-    prices.push({ symbol: wbtc18.symbol, address: wbtc18.address, usdPrice: wbtc.usdPrice })
+    res.push({ symbol: wbtc18.symbol, address: wbtc18.address, usdPrice: wbtc.usdPrice })
   }
 
-  return prices
+  return res
 }
 
+// ********************************************************************************
+// ********                                                                ********
+// ********                             GLOBAL                             ********
+// ********                                                                ********
+// ********************************************************************************
+
+export const fetchPrices = async (tokensToFetch: TokenToFetchWithChainId[] = tokens) => {
+  // Fetch on chain first
+  let prices: Price[] = await getOnChainPrices(tokensToFetch)
+
+  // Fetch from missing tokens from llama next
+  const pricesToFetchFromLlama = tokensToFetch
+    .map((t) => ({ ...t, usdPrice: prices.find((pl) => equalTlc(pl.address, t.address))?.usdPrice || 0 }))
+    .filter((t) => t.usdPrice === 0)
+
+  if (pricesToFetchFromLlama.length > 0) {
+    const llamaChunkedTokens = chunk(pricesToFetchFromLlama, 130)
+
+    for (const tokenChunk of llamaChunkedTokens) {
+      const httpArgs = tokenChunk.map((t) => `${getLlamaTokenPrefix(t.chainId)}:${t.address}`).toString()
+      const httpRequest = await fetch(`${LLAMA_API_URL}/prices/current/${httpArgs}`).then((res) => res.json())
+      const coinsData = httpRequest.coins
+
+      prices = prices.concat(
+        tokenChunk.map((t) => ({
+          symbol: t.symbol,
+          address: t.address,
+          usdPrice: coinsData[`${getLlamaTokenPrefix(t.chainId)}:${t.address}`]?.price || 0,
+        })),
+      )
+    }
+  }
+
+  const forcePrices = await Promise.all(
+    Object.keys(FORCE_GECKO_TERMINAL_TOKENS).map((chainId) =>
+      getPricesFromGeckoTerminal(FORCE_GECKO_TERMINAL_TOKENS[chainId], Number(chainId), []),
+    ),
+  ).then((res) => res.flat())
+
+  return [...forcePrices, ...prices]
+}
+
+// ********************************************************************************
+// ********                                                                ********
+// ********                             UTILS                              ********
+// ********                                                                ********
+// ********************************************************************************
+
 export const mergePrices = async (basePrices: Price[], tokens: TokenToFetch[], chainId = 1): Promise<Price[]> => {
   let fetchedPrices: Price[] = []
   if (tokens.length > 0) {

package/src/strategies/balancer/fetch.ts

@@ -14,11 +14,9 @@ import {
   tokenWithId,
 } from '@stake-dao/constants'
 import { batchBalancerStrats } from '../../bytecodes/index.js'
-import { concatBytecode, getBoost, getLogsFromEtherscan, getPricesFromLlama, getSdtApr } from '../../index.js'
+import { concatBytecode, getBoost, getPricesFromLlama, getSdtApr } from '../../index.js'
 import { equalTlc, graphql } from '../../utils.js'
-import { FACTORY_EVENT_TOPIC } from '../curve/endpoints.js'
 import type { BalancerGlobalData, RewardsData, Strategy, StrategyData, ValidChainId } from '../types.js'
-import decodeEtherscanFactoryEvent from '../utils/decodeEtherscanFactoryEvent.js'
 import { getAprBreakdown } from '../utils/getAprBreakdown.js'
 import getTokenTypes from '../utils/getTokenTypes.js'
 import { buildBalancerStrategies } from './build.js'
@@ -26,43 +24,17 @@ import { BALANCER_POOLS_DATA_QUERY, BALANCER_SUBGRAPH_URL } from './endpoints.js
 
 interface TFetchBalancer {
   provider: any
-  explorerApiKey: string
   chainId: ValidChainId
   sdtEmissionData: any
 }
 
-export const fetchBalancer = async ({
-  provider,
-  explorerApiKey,
-  chainId,
-  sdtEmissionData,
-}: TFetchBalancer): Promise<StrategyData> => {
+export const fetchBalancer = async ({ provider, chainId, sdtEmissionData }: TFetchBalancer): Promise<StrategyData> => {
   const currentBlockNumber = Number(await provider.getBlockNumber())
-  const fromBlock = balancerStrats.meta.lastSyncBlock[chainId]! + 1
   const toBlock = Number(await provider.getBlockNumber())
 
-  const httpCalls = [
-    // Etherscan Events
-    getLogsFromEtherscan({
-      chainId,
-      address: contracts.balancerVaultFactory![1]!,
-      apikey: explorerApiKey,
-      extraQueryParams: {
-        topic0: FACTORY_EVENT_TOPIC,
-        fromBlock: `${fromBlock}`,
-        toBlock: `${toBlock}`,
-      },
-    }),
-  ]
-
-  const httpResponses = (await Promise.allSettled(httpCalls)).map((result) =>
-    result.status === 'fulfilled' ? result.value : [],
-  )
-
-  const newVaultsAndLp = decodeEtherscanFactoryEvent(httpResponses[0])
   const vaultsAndLp = balancerStrats.strats[chainId] || []
 
-  const strats: any[] = await buildBalancerStrategies(provider, vaultsAndLp.concat(newVaultsAndLp), chainId)
+  const strats: any[] = await buildBalancerStrategies(provider, vaultsAndLp, chainId)
 
   const poolIds = strats.map((s) => s.key)
   const tokensToFetch: any = [tokenWithId('bal'), tokenWithId('sdt')]