@stake-dao/reader 0.1.0

package/src/batches/tokenData.ts

@@ -0,0 +1,26 @@
+import type { BatchMetaData } from './types.js'
+
+const commonBytecode =
+  '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'
+const commonInputType = ['address[] inputs']
+const commonOutputType = [
+  'Erc20Data[] erc20data',
+  'struct Erc20Data { string name; string symbol; address tokenAddress; uint256 decimals; }',
+]
+
+const tokenData: BatchMetaData = {
+  bytecode: {
+    1: commonBytecode,
+    42161: commonBytecode,
+  },
+  inputType: {
+    1: commonInputType,
+    42161: commonInputType,
+  },
+  outputTypeHr: {
+    1: commonOutputType,
+    42161: commonOutputType,
+  },
+}
+
+export default tokenData

package/src/batches/types.ts

@@ -0,0 +1,14 @@
+export type BatchMetaData = {
+  bytecode: {
+    [chainId: number]: `0x${string}`
+  }
+  inputType: {
+    [chainId: number]: string[]
+  }
+  outputType?: {
+    [chainId: number]: any[]
+  }
+  outputTypeHr: {
+    [chainId: number]: string[]
+  }
+}

package/src/endpoints.ts

@@ -0,0 +1,2 @@
+export const LLAMA_API_URL = 'https://coins.llama.fi'
+export const AGNOSTIC_QUERY_URL = 'https://proxy.eu-02.agnostic.engineering/query'

package/src/index.ts

@@ -0,0 +1,7 @@
+export { fetchCurve } from './strategies/curve/fetch/index.js'
+export { fetchCurveBase } from './strategies/curve/fetch/curveApiData/getCurveApiData.js'
+export { getGaugesWeights } from './strategies/curve/fetch/curveApiData/getGaugesWeights.js'
+export { getGaugesFromRegistry } from './strategies/curve/fetch/curveApiData/getGaugesFromRegistry.js'
+export { getPricesFromLlama, getPricesFromGeckoTerminal } from './prices.js'
+export { fetchSdt } from './sdt/sdt.js'
+export * from './strategies/utils/index.js'

package/src/number.ts

@@ -0,0 +1,51 @@
+import { formatUnits } from 'viem'
+
+export const getString = (data: any, nbDecimals = 2) => {
+  if (typeof data === 'string') {
+    return data
+  }
+  return data ? Number(data).toFixed(nbDecimals) : 0
+}
+
+export const getFixedNumber = (amount: string, reduce = false) => {
+  const earningsNumber = reduce ? Number(formatUnits(BigInt(amount), 18)) : Number(amount)
+  if (earningsNumber > 0 && earningsNumber < 1) {
+    const indexNotZero = earningsNumber.toString().match('[1-9]')
+    return indexNotZero?.index ? indexNotZero.index - 2 + 4 : 4
+  }
+  if (earningsNumber >= 1 && earningsNumber < 100) {
+    return 2
+  }
+  if (earningsNumber >= 100 && earningsNumber < 1000) {
+    return 2
+  }
+  return 0
+}
+
+export const fixed = (nb: string, decimals?: number) => {
+  const fixedTo = decimals ? decimals : getFixedNumber(nb)
+  return Number(nb).toLocaleString('en-US', {
+    minimumFractionDigits: fixedTo,
+    maximumFractionDigits: fixedTo,
+  })
+}
+
+export const formatUsd = (number: string | number) => {
+  const nb = typeof number === 'string' ? Number(number) : number
+
+  if (nb > 1000000000) {
+    return `${getString(nb / 1000000000, 2)}B`
+  }
+  if (nb > 1000000) {
+    return `${getString(nb / 1000000, 2)}M`
+  }
+  if (nb > 1000) {
+    return `${getString(nb / 1000, 2)}k`
+  }
+
+  return fixed(number.toString())
+}
+
+export const withTwoDec = (num: number) => {
+  return (Math.floor(num * 100) / 100).toFixed(2)
+}

package/src/prices.ts

@@ -0,0 +1,86 @@
+import { uniq } from 'lodash-es'
+
+const LLAMA_API_URL = 'https://coins.llama.fi'
+const GECKO_TERMINAL_API_URL = 'https://api.geckoterminal.com/api/v2'
+
+export type Price = {
+  symbol: string
+  address: string
+  usdPrice: number
+}
+
+export const getLlamaTokenPrefix = (chainId = 1): string => {
+  switch (chainId) {
+    case 1:
+      return 'ethereum'
+    case 137:
+      return 'polygon'
+    case 42161:
+      return 'arbitrum'
+    case 56:
+      return 'bsc'
+    default:
+      return 'ethereum'
+  }
+}
+
+export const getPricesFromLlama = async (tokens: any[], chainId = 1, defaultErrorValue?: any): Promise<Price[]> => {
+  try {
+    const prefix: string = getLlamaTokenPrefix(chainId)
+
+    const httpArgs = uniq(tokens.map((t) => `${prefix}:${t.address}`)).toString()
+    const httpRequest = await (await fetch(`${LLAMA_API_URL}/prices/current/${httpArgs}`)).json()
+    const coinsData = httpRequest.coins
+
+    const parsedPrice = tokens.map((t) => {
+      return {
+        symbol: t.symbol,
+        address: t.address,
+        usdPrice: coinsData[`${prefix}:${t.address}`] ? coinsData[`${prefix}:${t.address}`].price : 0,
+      }
+    })
+
+    return parsedPrice
+  } catch (e) {
+    console.error(e)
+    return defaultErrorValue
+  }
+}
+
+export const getPricesFromCurve = async (chainId: number) => {
+  const prefix = getLlamaTokenPrefix(chainId)
+  const httpRequest = (await fetch(`https://prices.curve.fi/v1/usd_price/${prefix}`)).json()
+
+  return httpRequest
+}
+
+export const getPricesFromGeckoTerminal = async (tokens: any[], chainId = 1, defaultErrorValue?: any): Promise<any> => {
+  try {
+    let network: string
+    switch (chainId) {
+      case 1:
+        network = 'eth'
+        break
+      case 137:
+        network = 'polygon_pos'
+        break
+      case 42161:
+        network = 'arbitrum'
+        break
+      default:
+        network = 'eth'
+        break
+    }
+
+    const httpArgs = uniq(tokens).join(',')
+    const httpRequest = await (
+      await fetch(`${GECKO_TERMINAL_API_URL}/simple/networks/${network}/token_price/${httpArgs}`)
+    ).json()
+    const coinsData = httpRequest.data.attributes.token_prices
+
+    return coinsData
+  } catch (e) {
+    console.error(e)
+    return defaultErrorValue
+  }
+}

package/src/sdt/sdt.ts

@@ -0,0 +1,110 @@
+import { formatUnits, parseAbi, parseUnits } from 'viem'
+
+import { ONE_DAY, type Token, contracts, tokenWithId } from '@stake-dao/constants'
+import { Zero } from '../index.js'
+import { type Price } from '../prices.js'
+import { agnostic, multicall } from '../utils.js'
+import veSdtAlternativeYields from './veSdtAlternativeYields.js'
+
+const AGNOSTIC_QUERY = (timeLimit: number) => `
+	select
+		input_0_value_uint256 as time,
+		input_1_value_uint256 as tokens
+	from evm_events_ethereum_mainnet
+	where
+		address = '${contracts.veSdtFeeDistributor![1]!}' and
+		input_1_value_uint256 != '0' and
+		input_0_value_uint256 > '${timeLimit}' and
+		signature = 'CheckpointToken(uint256,uint256)'
+	ORDER BY time DESC
+`
+
+export const fetchSdt = async (prices: Price[], provider: any, agnosticKey?: string) => {
+  const sdtToken = tokenWithId('sdt') as Token
+  const frax3CrvToken = tokenWithId('frax3crv') as Token
+
+  const now = Math.ceil(new Date().getTime() / 1000)
+  const lastCheck = now - ONE_DAY * 28
+
+  let agnosticData: any[] | null = null
+  if (agnosticKey) {
+    const httpCalls = [await agnostic(AGNOSTIC_QUERY(lastCheck), agnosticKey)]
+    const httpResponses = (await Promise.allSettled(httpCalls))
+      .flatMap((d) => (d.status === 'fulfilled' ? d.value : d.reason))
+      .flat()
+    agnosticData = httpResponses[0]
+  }
+
+  const rawSdtData: any = await multicall(
+    provider,
+    [
+      { address: contracts.sdFrx3CrvVault![1]!, name: 'getPricePerFullShare' },
+      { address: sdtToken.address, name: 'balanceOf', params: [contracts.veSdt![1]!] },
+      { address: sdtToken.address, name: 'balanceOf', params: [contracts.vestedSdt![1]!] },
+      { address: sdtToken.address, name: 'totalSupply' },
+      { address: contracts.veSdt![1]!, name: 'totalSupply' },
+      {
+        address: contracts.veSdtBoostDelegation![1]!,
+        name: 'received_balance',
+        params: [contracts.voteBoosterStrategy![1]!],
+      },
+      { address: contracts.liquidLockersGaugeController![1]!, name: 'get_total_weight' },
+      { address: contracts.sdGaugeController![1]!, name: 'get_total_weight' },
+    ],
+    parseAbi([
+      'function getPricePerFullShare() external view returns (uint256)',
+      'function balanceOf(address user) external view returns (uint256)',
+      'function totalSupply() external view returns (uint256)',
+      'function received_balance(address user) external view returns (uint256)',
+      'function get_total_weight() external view returns (uint256)',
+    ]),
+  )
+
+  const vaultRatio = rawSdtData[0].result
+  const lockedSdtBalance = rawSdtData[1].result
+  const vestedSdtBalance = rawSdtData[2].result
+  const sdtTotalSupply = rawSdtData[3].result
+  const veSdtTotalSupply = rawSdtData[4].result
+  const voteBoosterVeSdt = rawSdtData[5].result
+
+  const sdtPrice = prices?.find((p) => p.address.toLowerCase() === sdtToken.address.toLowerCase())?.usdPrice || 0
+  const frax3CrvPrice =
+    prices?.find((p) => p.address.toLowerCase() === frax3CrvToken.address.toLowerCase())?.usdPrice || 0
+
+  const lockedInUsd = parseUnits(`${sdtPrice}`, sdtToken.decimals) * lockedSdtBalance
+  const vestedInUsd = parseUnits(`${sdtPrice}`, sdtToken.decimals) * vestedSdtBalance
+  const percentLocked = parseUnits(formatUnits(lockedSdtBalance, 0), sdtToken.decimals) / sdtTotalSupply
+  const averageLock = (parseUnits(formatUnits(veSdtTotalSupply, 0), sdtToken.decimals) / lockedSdtBalance) * BigInt(4)
+
+  let rewardsAmount = Zero
+  let checkedWeek = now - ONE_DAY * 7
+
+  let apr = 0
+  if (agnosticData) {
+    while (lastCheck <= checkedWeek && rewardsAmount === Zero) {
+      const checkedWeekAgnostic = agnosticData ? agnosticData.filter((d: any) => checkedWeek < Number(d[0])) : null
+      rewardsAmount = checkedWeekAgnostic ? checkedWeekAgnostic.reduce((total, d) => total + BigInt(d[1]), Zero) : Zero
+      checkedWeek = checkedWeek - ONE_DAY * 7
+    }
+
+    apr =
+      ((frax3CrvPrice * Number(formatUnits(rewardsAmount, 18)) * 52) / Number(formatUnits(vestedInUsd, 18))) *
+      Number(vaultRatio)
+  }
+
+  const parsedData = {
+    alternativeYields: veSdtAlternativeYields,
+    veSdtTotalSupply: formatUnits(veSdtTotalSupply, 0),
+    locked: formatUnits(lockedSdtBalance, 0),
+    lockedInUsd: Number(formatUnits(lockedInUsd, sdtToken.decimals * 2)),
+    vestedInUsd: Number(formatUnits(vestedInUsd, sdtToken.decimals * 2)),
+    percentLocked: Number(formatUnits(percentLocked, 18)) * 100,
+    averageLockInYears: Number(formatUnits(averageLock, 18)),
+    apr: apr * 100,
+    voteBoosterVeSdt: Number(formatUnits(voteBoosterVeSdt, sdtToken.decimals)),
+    lockersTotalWeight: formatUnits(rawSdtData[6].result, 0),
+    stratsTotalWeight: formatUnits(rawSdtData[7].result, 0),
+  }
+
+  return parsedData
+}

package/src/sdt/veSdtAlternativeYields.ts

@@ -0,0 +1,19 @@
+const veSdtAlternativeYields = {
+  wardenMarket: {
+    label: 'Market',
+    platform: 'Warden',
+    href: 'https://app.warden.vote/boosts/market/',
+  },
+  wardenPledge: {
+    label: 'Pledge',
+    platform: 'Warden',
+    href: 'https://app.warden.vote/boosts/pledge/',
+  },
+  asdcrvDelegation: {
+    label: 'asdCRV Delegation',
+    platform: 'Concentator',
+    href: 'https://concentrator.aladdin.club/#/vault',
+  },
+}
+
+export default veSdtAlternativeYields

package/src/strategies/curve/build.ts

@@ -0,0 +1,187 @@
+import { chunk, remove, uniq } from 'lodash-es'
+import { decodeAbiParameters, encodeAbiParameters, parseAbi, parseAbiParameters } from 'viem'
+
+import { contract, tokens } from '@stake-dao/constants'
+import type { FetchedToken, Token } from '@stake-dao/constants'
+import { batchSdtGaugeRewards, batchTokenData } from '../../batches/index.js'
+import { equalTlc, getTokenInfo } from '../../utils.js'
+
+interface VaultAndLp {
+  vault: string
+  lpToken: string
+}
+
+export const buildCurveStrategies = async (
+  provider: any,
+  stratsList: VaultAndLp[],
+  chainId: number,
+  externalApisResult: any[],
+) => {
+  const tokensToFetch: string[] = []
+  const gaugesToFetch: string[] = []
+
+  const strats = stratsList.map((data) => {
+    const lpToken = data.lpToken
+    const curveApiData = externalApisResult.find((el) => equalTlc(el.lp, lpToken))
+
+    if (curveApiData) {
+      const isMetapool = curveApiData.isMetapool
+      const isLending = curveApiData.isLending
+
+      const coins: string[] = curveApiData.coins.map((c) => c.coinAddress)
+
+      let underlyingCoins: string[] = []
+      if (isMetapool || isLending) {
+        underlyingCoins = curveApiData.underlyingCoins
+      }
+
+      const gaugeAddress = curveApiData.gauge?.address || undefined
+
+      for (const coin of coins) tokensToFetch.push(coin)
+      for (const uCoin of underlyingCoins) tokensToFetch.push(uCoin)
+      tokensToFetch.push(lpToken)
+
+      if (typeof gaugeAddress === 'undefined') {
+        gaugesToFetch.push(data.vault)
+      }
+
+      return {
+        type: curveApiData.poolType,
+        key: `${curveApiData.poolType}-${curveApiData.id}`,
+        isMetapool,
+        isLending,
+        coins,
+        vault: data.vault,
+        lpToken,
+        gaugeAddress,
+        underlyingCoins,
+      }
+    }
+
+    return {
+      type: undefined,
+      key: undefined,
+      isMetapool: undefined,
+      isLending: undefined,
+      coins: [],
+      vault: data.vault,
+      lpToken,
+      gaugeAddress: undefined,
+      underlyingCoins: [],
+    }
+  })
+
+  // Fetch tokens infos
+  const inputArgsChunks = chunk(
+    remove(uniq(tokensToFetch), (t) => !tokens.find((token: Token) => token.address === t)),
+    40,
+  )
+  const decodedPromise = await Promise.allSettled(
+    inputArgsChunks.map(async (inputArgs) => {
+      const inputData = encodeAbiParameters(parseAbiParameters(batchTokenData.inputType[chainId] || []) as any, [
+        inputArgs,
+      ])
+      const contractCreationCode = batchTokenData.bytecode[chainId]?.concat(inputData.slice(2))
+      const returnedData = await provider.call({
+        data: contractCreationCode,
+      })
+      return decodeAbiParameters(
+        parseAbiParameters(batchTokenData.outputTypeHr[chainId] || []) as any,
+        returnedData.data,
+      )
+    }),
+  )
+
+  const fetchedTokenData = decodedPromise.flatMap((d) => (d.status === 'fulfilled' ? d.value : [])).flat()
+
+  // Fetch Sdt Gauge rewards tokens infos
+  const sdtGaugeInputArgsChunks = chunk(
+    stratsList.map((data) => data.vault),
+    20,
+  )
+  const sdtGaugedecodedPromise = await Promise.allSettled(
+    sdtGaugeInputArgsChunks.map(async (inputArgs) => {
+      const inputData = encodeAbiParameters(parseAbiParameters(batchSdtGaugeRewards.inputType[chainId] || []) as any, [
+        inputArgs,
+      ])
+      const contractCreationCode = batchSdtGaugeRewards.bytecode[chainId]?.concat(inputData.slice(2))
+      const returnedData = await provider.call({
+        data: contractCreationCode,
+      })
+      return decodeAbiParameters(
+        parseAbiParameters(batchSdtGaugeRewards.outputTypeHr[chainId] || []) as any,
+        returnedData.data,
+      )
+    }),
+  )
+  const fetchedSdtGaugeData = sdtGaugedecodedPromise.flatMap((d) => (d.status === 'fulfilled' ? d.value : [])).flat()
+
+  // Fetch Curve Lending Gauges
+  let curveLendingGauges: any[] = []
+  let curveLendingGaugesIndex = 0
+
+  if (chainId === 1) {
+    curveLendingGauges = await provider.multicall({
+      contracts: strats
+        .map((s) =>
+          s.isLending
+            ? {
+                abi: parseAbi(['function gauge_for_vault(address _vault) external view returns (address)']),
+                address: contract('curveOneWayLendingFactory', chainId),
+                functionName: 'gauge_for_vault',
+                args: [s.lpToken],
+              }
+            : undefined,
+        )
+        .filter(Boolean),
+    })
+  }
+
+  const stratsData = strats.map((s, index) => {
+    const coinsData = s.coins.map((c: string) =>
+      getTokenInfo(
+        fetchedTokenData.find((t) => equalTlc(t.tokenAddress, c)),
+        c,
+        chainId,
+      ),
+    )
+    const underlyingCoinsData = s.underlyingCoins.map((c: string) =>
+      getTokenInfo(
+        fetchedTokenData.find((t) => equalTlc(t.tokenAddress, c)),
+        c,
+        chainId,
+      ),
+    )
+    const stakeTokenData = getTokenInfo(
+      fetchedTokenData.find((t) => equalTlc(t.tokenAddress, s.lpToken)),
+      s.lpToken,
+      chainId,
+    )
+
+    let gaugeAddress: string = s.gaugeAddress
+    if (s.isLending) {
+      gaugeAddress = curveLendingGauges[curveLendingGaugesIndex]?.result
+      curveLendingGaugesIndex += 1
+    }
+
+    return {
+      key: s.key,
+      type: s.type,
+      protocol: 'curve',
+      chainId: chainId,
+      isMetapool: s.isMetapool,
+      isLending: s.isLending,
+      vault: s.vault,
+      lpToken: stakeTokenData,
+      gaugeAddress,
+      coins: coinsData,
+      underlyingCoins: underlyingCoinsData,
+      sdGauge: fetchedSdtGaugeData[index]?.gauge || undefined,
+      rewards: fetchedSdtGaugeData[index].rewards.map((tokenInfo: FetchedToken) =>
+        getTokenInfo(tokenInfo, tokenInfo.tokenAddress, chainId),
+      ),
+    }
+  })
+
+  return stratsData
+}

package/src/strategies/curve/endpoints.ts

@@ -0,0 +1,21 @@
+export const FACTORY_EXPLORER_EVENTS = (
+  apiKey: string,
+  explorer: string,
+  contract: string,
+  fromBlock: number,
+  toBlock: number | 'latest' = 'latest',
+) =>
+  `https://api.${explorer}/api?module=logs&action=getLogs&address=${contract}&fromBlock=${fromBlock}&toBlock=${toBlock}&topic0=0x26ad9f07a47e389150a15677a365d64f42af0000b792c182ada6a3b5ab193a0b&apikey=${apiKey}`
+
+export const NEW_FACTORY_EXPLORER_EVENTS = (
+  apiKey: string,
+  explorer: string,
+  contract: string,
+  fromBlock: number,
+  toBlock: number | 'latest' = 'latest',
+) =>
+  `https://api.${explorer}/api?module=logs&action=getLogs&address=${contract}&fromBlock=${fromBlock}&toBlock=${toBlock}&topic0=0x5f7560a5797edc6f72421362defa094d690eb9f7ced3cc5a5c13383502e4fcc5&apikey=${apiKey}`
+
+export const CURVE_API_URL = 'https://api.curve.fi/api'
+export const CONVEX_POOLS_URL = 'https://curve.convexfinance.com/api/curve/pools'
+export const CONVEX_LENDING_VAULTS_URL = 'https://curve.convexfinance.com/api/curve/lending-vaults'

package/src/strategies/curve/fetch/curveApiData/abi.ts

@@ -0,0 +1,81 @@
+export const getCurveDataPoolsOutputTypeAbi = (isLending: boolean) => [
+  {
+    type: 'tuple[]',
+    name: 'returnData',
+    components: [
+      { type: 'uint256', name: 'id' },
+      { type: 'address', name: 'lp' },
+      { type: 'address', name: 'pool' },
+      { type: 'uint256', name: 'totalSupply' },
+      { type: 'address', name: 'gauge' },
+      { type: 'bool', name: 'isMetapool' },
+      {
+        type: 'tuple[]',
+        name: 'coins',
+        components: [
+          { type: 'address', name: 'coinAddress' },
+          { type: 'uint256', name: 'decimals' },
+          { type: 'uint256', name: 'balance' },
+        ],
+      },
+      { type: 'address[]', name: 'underlyingCoins' },
+      ...(isLending
+        ? [
+            {
+              type: 'tuple',
+              name: 'ext',
+              components: [
+                { type: 'uint256', name: 'pricePerShare' },
+                { type: 'uint256', name: 'lendApr' },
+              ],
+            },
+          ]
+        : []),
+    ],
+  },
+]
+
+export const getCurveDataGaugesWeightsOutputTypeAbi = [
+  {
+    type: 'tuple[]',
+    name: 'returnData',
+    components: [
+      { type: 'address', name: 'gauge' },
+      { type: 'uint256', name: 'relativeWeight' },
+      { type: 'uint256', name: 'futureRelativeWeight' },
+    ],
+  },
+]
+
+export const getCurveDataGaugesOutputTypeAbi = [
+  {
+    type: 'tuple[]',
+    name: 'returnData',
+    components: [
+      { type: 'address', name: 'gauge' },
+      { type: 'address', name: 'lpToken' },
+      { type: 'bool', name: 'isKilled' },
+      { type: 'uint256', name: 'inflationRate' },
+      { type: 'uint256', name: 'workingSupply' },
+      {
+        type: 'tuple[]',
+        name: 'rewards',
+        components: [
+          {
+            type: 'tuple',
+            name: 'token',
+            components: [
+              { type: 'address', name: 'tokenAddress' },
+              { type: 'string', name: 'name' },
+              { type: 'string', name: 'symbol' },
+              { type: 'uint256', name: 'decimals' },
+            ],
+          },
+          { type: 'address', name: 'distributor' },
+          { type: 'uint256', name: 'periodFinish' },
+          { type: 'uint256', name: 'rate' },
+        ],
+      },
+    ],
+  },
+]