@stake-dao/reader 0.4.111 → 0.5.0

package/src/lockers/fetch/parse.ts

@@ -0,0 +1,258 @@
+import { ONE_WEEK, ONE_YEAR, Zero } from '@stake-dao/constants'
+import { formatUnits, parseUnits } from 'viem'
+import { equalTlc } from '../../utils.js'
+import getBribesRewardsData, { type TBribesRewards } from '../utils/getBribesRewardsData.js'
+import substractFees from '../utils/substractFees.js'
+import type { Locker } from './types.js'
+
+export const parseVoteBoosterData = (locker: Locker, voteBooster: any) => {
+  const voteBoosterBoost =
+    voteBooster && Number(voteBooster.working) > 0 && Number(voteBooster.staked) > 0
+      ? Number(voteBooster.working) / (Number(voteBooster.staked) * 0.4)
+      : 1
+
+  return {
+    booster: locker.voteBooster!.booster,
+    vSdToken: locker.voteBooster!.vSdToken,
+    balance: voteBooster,
+    boost: voteBoosterBoost,
+  }
+}
+
+export const parsePeg = (locker: Locker, rawPeg: any) => {
+  if (rawPeg && rawPeg !== '-') {
+    const pegBase = parseUnits(locker.secondaryMarket?.pegBase?.toString() || '1', 0)
+    return formatUnits(rawPeg / pegBase, 18)
+  }
+
+  return '-'
+}
+
+export const parseAltYields = (locker: Locker, common: any) => {
+  const alternativeYields = JSON.parse(JSON.stringify(locker.alternativeYields || {})) // parse and stringify to avoid extensible issue
+
+  try {
+    if (common.cvgAprs?.[locker.modules.gauge]) {
+      alternativeYields.convergenceSdToken = {
+        label: locker.sdToken.symbol,
+        platform: 'Convergence',
+        href: 'https://app.cvg.finance/',
+        apr: common.cvgAprs[locker.modules.gauge].totalApr,
+      }
+    }
+
+    const spectraAltYield = common.spectraAprs?.find((s) => equalTlc(s.underlying.address, locker.sdToken.address))
+
+    alternativeYields.spectraAsdToken = spectraAltYield
+      ? {
+          label: spectraAltYield.ibt.symbol,
+          platform: 'Spectra',
+          href: 'https://app.spectra.finance/pools',
+          apr: Math.max(spectraAltYield.pools.map((p) => p.lpApy?.total || 0) || [0]),
+        }
+      : undefined
+  } catch (e) {
+    console.error(e)
+  }
+
+  return alternativeYields
+}
+
+export const parseVeBoostApr = (weeklyRewards: any, tokenPriceInUsd: number, totalDelegatedVeBoost: number) => {
+  let amountPerYear = 0
+
+  try {
+    const weeklyRewardsWithoutNull = weeklyRewards
+      .filter((r) => r > Zero)
+      .map((r) => Number(formatUnits(r as bigint, 18)))
+
+    if (weeklyRewardsWithoutNull.length > 0) {
+      amountPerYear =
+        (weeklyRewardsWithoutNull.reduce((total, x) => (total += x), 0) /
+          (weeklyRewardsWithoutNull.length * ONE_WEEK)) *
+        ONE_YEAR
+    }
+  } catch (e) {
+    console.error(e)
+    amountPerYear = 0
+  }
+
+  const tvl = Number(totalDelegatedVeBoost) * tokenPriceInUsd
+  const apr = tvl > 0 ? ((amountPerYear * tokenPriceInUsd) / tvl) * 100 : 0
+
+  return apr
+}
+
+export const parseSidechains = (locker, raw, prices) => {
+  if (locker.extensions.sideChains && raw.sidechains) {
+    return locker.extensions.sideChains.map((s, index) => {
+      const rewards =
+        s.rewards?.map((reward) => {
+          const price = prices.find((p) => equalTlc(p.address, reward.address))?.usdPrice || 0
+          return { token: reward, price }
+        }) || []
+
+      return {
+        ...s,
+        ...raw.sidechains[index],
+        rewards,
+      }
+    })
+  }
+
+  return undefined
+}
+
+export interface RawLockersData {
+  tokenLocked: string
+  veBalanceOfLocker: string
+  totalTokenLocked: string
+  veTotalSupply: string
+  totalSupplyStaked: string
+  gaugeWorkingSupply: string
+  amountTokenNotLock: string
+  sdTokenInPool: string
+  lockIncentive?: string
+  peg: string
+  rewards: any[]
+  veBoost?: {
+    delegated: string
+    weeklyRewards: string[]
+  }
+  voteBooster?: {
+    token: string
+    sdToken: string
+    staked: string
+    working: string
+  }
+  veTokenRate: string
+  _workingSupply: string
+  _veBalanceOfLocker: string
+  replaceApr?: number[]
+  sidechains?: any[]
+}
+
+export interface ParseLockers {
+  locker: any
+  raw: RawLockersData
+  common: {
+    bribesData: { [locker: string]: number }
+    veSdtTotalSupply: bigint
+  }
+  prices: any[]
+}
+
+export const parse = async ({ locker, raw, common, prices }: ParseLockers) => {
+  const lockerFee = { total: 15 }
+
+  const tokenPrice = prices.find((p) => p.address === locker.token.address)
+  const tokenPriceInUsd = tokenPrice ? tokenPrice.usdPrice : 0
+  const sdTokenPriceInUsd = raw.peg !== '-' ? tokenPriceInUsd * Number(raw.peg) : tokenPriceInUsd
+
+  const tvl = raw.totalSupplyStaked ? Number(raw.totalSupplyStaked) * sdTokenPriceInUsd : 0
+
+  const veBoostApr =
+    locker.veBoost && raw.veBoost
+      ? parseVeBoostApr(raw.veBoost.weeklyRewards, tokenPriceInUsd, Number(raw.veBoost.delegated))
+      : 0
+
+  // Rewards APR
+  const rewardsData = raw.rewards.map((rawData, index) => {
+    const r = locker.rewards[index]
+    const rewardPrice = equalTlc(r.address, locker.sdToken.address)
+      ? sdTokenPriceInUsd
+      : prices.find((p) => p.address === r.address)?.usdPrice || 0
+
+    const periodFinish = Number(formatUnits(rawData ? rawData[2] : Zero, 0))
+    let streaming = r.distribution === 'streamed' && periodFinish > Math.floor(Date.now() / 1000)
+
+    const rate = rawData ? rawData[3] : Zero
+    const oneYearRate = rate * BigInt(ONE_YEAR)
+
+    let apr = streaming
+      ? rewardPrice && tvl > 0
+        ? ((Number(formatUnits(oneYearRate, r.decimals)) * rewardPrice) / tvl) * 100
+        : 0
+      : 0
+
+    if (raw.replaceApr?.[index]) {
+      apr = raw.replaceApr[index]
+      streaming = apr > 0
+    }
+
+    // Remove fees from APR
+    apr = substractFees(locker.id, apr, lockerFee)
+
+    return {
+      token: r,
+      price: rewardPrice,
+      apr,
+      streaming,
+      periodFinish,
+      rate: formatUnits(rate, 0),
+      lastUpdate: rawData ? formatUnits(rawData[4], 0) : '0',
+      isAirdrop: r.isAirdrop,
+    }
+  })
+
+  const data = getBribesRewardsData(
+    locker,
+    common.bribesData,
+    common.veSdtTotalSupply,
+    raw.totalSupplyStaked,
+    raw._veBalanceOfLocker,
+    raw._workingSupply,
+    raw.sdTokenInPool,
+    raw.tokenLocked,
+  )
+
+  const bribeMinApr: number = data.bribeMinApr
+  const bribeMaxApr: number = data.bribeMaxApr
+  const bribeRewards: TBribesRewards | undefined = data.bribeRewards
+
+  // Total APR
+  const minRewardsAprs = rewardsData.reduce((x, y) => x + y.apr, 0) + bribeMinApr
+  const maxRewardsAprs = rewardsData.reduce((x, y) => x + y.apr, 0) + bribeMaxApr
+
+  // Streaming status
+  const streaming = rewardsData.some((r) => r.streaming)
+  const alternativeYields = parseAltYields(locker, common)
+
+  // Sidechains
+  const sideChains = parseSidechains(locker, raw, prices)
+
+  return {
+    ...locker,
+    rewards: rewardsData,
+    tokenLocked: raw.tokenLocked,
+    veBalanceOfLocker: raw.veBalanceOfLocker,
+    totalTokenLocked: raw.totalTokenLocked,
+    veTotalSupply: raw.veTotalSupply,
+    lockIncentive: raw.lockIncentive || '0',
+    gaugeWorkingSupply: raw.gaugeWorkingSupply,
+    totalSupplyStaked: raw.totalSupplyStaked,
+    amountTokenNotLock: raw.amountTokenNotLock,
+    bribeRewards,
+    apr: [minRewardsAprs, maxRewardsAprs],
+    streaming,
+    veTokenRate: raw.veTokenRate,
+    tvl,
+    peg: raw.peg,
+    tokenPriceInUsd,
+    sdTokenPriceInUsd,
+    alternativeYields,
+    extensions: {
+      ...locker.extensions,
+      sideChains,
+    },
+    veBoost:
+      locker.veBoost && raw.veBoost
+        ? {
+            ...locker.veBoost,
+            delegated: raw.veBoost.delegated,
+            apr: veBoostApr,
+          }
+        : undefined,
+    voteBooster: raw.voteBooster,
+  }
+}

package/src/lockers/fetch/protocols/angle.ts

@@ -0,0 +1,157 @@
+import { One, STAKE_DAO_ASSETS_BASE_URL, Zero, tokenWithId } from '@stake-dao/constants'
+import { formatUnits, parseUnits } from 'viem'
+import lockersMulticallAbi from '../../../abis/lockersMulticall.js'
+import { type Call, getRes, multicall } from '../../../utils.js'
+import { parse, parsePeg } from '../parse.js'
+import type { Locker } from '../types.js'
+
+export const locker: Locker = {
+  id: 'angle',
+  symbol: 'ANGLE',
+  protocol: 'Angle',
+  protocolDescription:
+    'Angle is a decentralized, capital efficient and over-collateralized stablecoin protocol composed of smart contracts running on open blockchains.',
+  website: 'https://angle.money/',
+  logoUrl: `${STAKE_DAO_ASSETS_BASE_URL}/assets/archive/angle.svg`,
+  chainId: 1,
+  rgb: '249, 145, 144',
+  token: tokenWithId('angle')!,
+  sdToken: tokenWithId('sdangle')!,
+  rewards: [
+    { ...tokenWithId('sdt')!, distribution: 'streamed', origin: 'sdtEmission' },
+    { ...tokenWithId('angle')!, distribution: 'streamed', origin: 'stratPerf' },
+    { ...tokenWithId('eura')!, distribution: 'streamed', origin: 'native.common' },
+    { ...tokenWithId('sdangle')!, distribution: 'distributed', origin: 'bounties' },
+  ],
+  delegation: ['sdangle.eth'],
+  modules: {
+    depositor: '0x0000000000000000000000000000000000000000',
+    locker: '0xD13F8C25CceD32cdfA79EB5eD654Ce3e484dCAF5',
+    veToken: '0x0C462Dbb9EC8cD1630f1728B2CFD2769d09f0dd5',
+    gauge: '0xE55843a90672f7d8218285e51EE8fF8E233F35d5',
+    accumulator: '0x8cc02F4f383A11b989708437DbA6BB0628d7eE78',
+    redeem: '0x1D8A9c30E4e25033498347c1A054717bd0c4D356',
+  },
+  secondaryMarket: {
+    label: 'Curve',
+    poolKey: 'factory-v2-101',
+    vaultKey: '',
+    pool: '0x48fF31bBbD8Ab553Ebe7cBD84e1eA3dBa8f54957',
+    pools: ['0x48fF31bBbD8Ab553Ebe7cBD84e1eA3dBa8f54957'],
+    pegBase: 300000,
+  },
+  fees: [
+    {
+      label: { key: 'liquidity', variable: 'sdANGLE/ANGLE' },
+      value: 10,
+      key: 'liquidityFee',
+      static: true,
+    },
+    {
+      label: { key: 'treasury' },
+      value: 5,
+      key: 'daoFee',
+      static: true,
+    },
+    {
+      label: { key: 'harvester' },
+      value: 0.1,
+      key: 'claimerFee',
+      static: true,
+    },
+  ],
+  extensions: {
+    coingeckoBaseSlug: 'angle',
+  },
+}
+
+const angleLocker = async ({ provider, common, prices }: { provider; common; prices }) => {
+  const token = locker.token.address
+  const sdToken = locker.sdToken.address
+
+  const gauge = locker.modules.gauge
+  const depositor = locker.modules.depositor
+  const votingEscrow = locker.modules.veToken
+  const lockerAddress = locker.modules.locker
+
+  const secondaryMarket = locker.secondaryMarket!
+  const rewards = locker.rewards
+
+  const pegBase = parseUnits(secondaryMarket?.pegBase?.toString() || '1', 18)
+
+  const format = (value: bigint) => formatUnits(value, locker.token.decimals)
+  const formatRes = (value: any) => format(getRes(value))
+
+  const calls: Call[] = [
+    /*********************************************************************************
+     *** Voting Escrow
+     *********************************************************************************/
+
+    // Token locked by the Locker
+    { address: votingEscrow, name: 'locked', params: [lockerAddress] },
+    // veToken Balance of the Locker
+    { address: votingEscrow, name: 'balanceOf', params: [lockerAddress] },
+    // Total token locked
+    { address: votingEscrow, name: 'supply' },
+    // Total veToken supply
+    { address: votingEscrow, name: 'totalSupply' },
+
+    /*********************************************************************************
+     *** Gauge
+     *********************************************************************************/
+
+    // Total sdToken staked
+    { address: gauge, name: 'totalSupply' },
+    // Gauge working supply
+    { address: gauge, name: 'working_supply' },
+
+    /*********************************************************************************
+     *** Token & sdToken
+     *********************************************************************************/
+
+    // Token balance not locked
+    { address: token, name: 'balanceOf', params: [depositor] },
+    // sdToken in secondary market pool
+    { address: sdToken, name: 'balanceOf', params: [secondaryMarket.pool] },
+
+    /*********************************************************************************
+     *** Peg
+     *********************************************************************************/
+
+    // Return amount when swapping {pegBase} sdToken to token -> get_dy(int128,int128,uint256)
+    { address: secondaryMarket.pool, name: '0x5e0d443f', params: [One, Zero, pegBase] },
+
+    /*********************************************************************************
+     *** Rewards
+     *********************************************************************************/
+
+    // Streaming status for each reward token
+    ...rewards.map((r) => ({ address: gauge, name: 'reward_data', params: [r.address] })),
+  ]
+
+  const res = await multicall(provider, calls, lockersMulticallAbi(locker.id, locker.chainId))
+  const raw = {
+    tokenLocked: getRes(res.shift()),
+    veBalanceOfLocker: formatRes(res.shift()),
+    totalTokenLocked: formatRes(res.shift()),
+    veTotalSupply: formatRes(res.shift()),
+    totalSupplyStaked: formatRes(res.shift()),
+    gaugeWorkingSupply: formatRes(res.shift()),
+    amountTokenNotLock: formatRes(res.shift()),
+    sdTokenInPool: formatRes(res.shift()),
+    peg: getRes(res.shift()),
+    rewards: rewards.map(() => getRes(res.shift())),
+    veTokenRate: '4',
+    _workingSupply: '0',
+    _veBalanceOfLocker: '0',
+  }
+
+  raw.tokenLocked = format(raw.tokenLocked[0])
+  raw.peg = parsePeg(locker, raw.peg)
+  raw._workingSupply = raw.gaugeWorkingSupply
+  raw._veBalanceOfLocker = raw.veBalanceOfLocker
+
+  return parse({ locker, common, prices, raw })
+}
+
+export default angleLocker

package/src/lockers/fetch/protocols/balancer.ts

@@ -0,0 +1,195 @@
+import { ONE_WEEK, One, STAKE_DAO_ASSETS_BASE_URL, Zero, contracts, tokenWithId } from '@stake-dao/constants'
+import { range } from 'lodash-es'
+import { type Address, formatUnits, parseUnits, zeroAddress } from 'viem'
+import lockersMulticallAbi from '../../../abis/lockersMulticall.js'
+import { type Call, getRes, multicall } from '../../../utils.js'
+import { parse, parsePeg } from '../parse.js'
+import type { Locker } from '../types.js'
+
+export const locker: Locker = {
+  id: 'bal',
+  symbol: 'BAL',
+  protocol: 'Balancer',
+  protocolDescription:
+    'Balancer is a decentralized automated market maker (AMM) protocol built on Ethereum that represents a flexible building block for programmable liquidity.',
+  website: 'https://balancer.fi/',
+  logoUrl: `${STAKE_DAO_ASSETS_BASE_URL}/assets/archive/bal.svg`,
+  chainId: 1,
+  rgb: '9, 31, 59',
+  token: tokenWithId('80-bal-20-weth')!,
+  sdToken: tokenWithId('sdbal')!,
+  rewards: [
+    { ...tokenWithId('sdt')!, distribution: 'streamed', origin: 'sdtEmission' },
+    { ...tokenWithId('bal')!, distribution: 'streamed', origin: 'stratPerf' },
+    { ...tokenWithId('usdc')!, distribution: 'streamed', origin: 'native.common' },
+    { ...tokenWithId('sdbal')!, distribution: 'distributed', origin: 'bounties' },
+  ],
+  delegation: ['sdbal.eth'],
+  modules: {
+    depositor: '0x3e0d44542972859de3CAdaF856B1a4FD351B4D2E',
+    locker: '0xea79d1a83da6db43a85942767c389fe0acf336a5',
+    veToken: '0xC128a9954e6c874eA3d62ce62B468bA073093F25',
+    gauge: '0x3e8c72655e48591d93e6dfda16823db0ff23d859',
+    accumulator: '0x2903DBEC58d193c34708dE22f89fd7A42b6d0Eb0',
+  },
+  secondaryMarket: {
+    label: 'Balancer',
+    poolKey: '0x2d011adf89f0576c9b722c28269fcb5d50c2d17900020000000000000000024d',
+    vaultKey: '0x2d011adf89f0576c9b722c28269fcb5d50c2d17900020000000000000000024d',
+    pool: '0x2d011adf89f0576c9b722c28269fcb5d50c2d17900020000000000000000024d',
+    pools: [contracts.balancerVault![1] as Address],
+    router: contracts.balancerVault![1] as Address,
+    pegBase: 1000,
+  },
+  veBoost: {
+    address: '0x2cf8e145Bdfe7c52b49AD9bB3c294a31B2736c59',
+    delegator: '0xda9846665Bdb44b0d0CAFFd0d1D4A539932BeBdf',
+  },
+  alternativeYields: {
+    sdBalBalStakeDao: {
+      label: 'sdBAL/B-80BAL-20WETH',
+      platform: 'Stake DAO',
+      href: '/yield',
+    },
+  },
+  fees: [
+    {
+      label: { key: 'liquidity', variable: 'sdBAL/B-80BAL-20WETH' },
+      value: 10,
+      key: 'liquidityFee',
+    },
+    {
+      label: { key: 'treasury' },
+      value: 5,
+      key: 'daoFee',
+    },
+    {
+      label: { key: 'harvesterOn', variable: 'BAL, USDC' },
+      value: 0,
+      key: 'claimerFee',
+    },
+  ],
+  extensions: {
+    coingeckoBaseSlug: 'balancer',
+  },
+}
+
+const balancerLocker = async ({ provider, common, prices }: { provider; common; prices }) => {
+  const token = locker.token.address
+  const sdToken = locker.sdToken.address
+
+  const gauge = locker.modules.gauge
+  const depositor = locker.modules.depositor
+  const votingEscrow = locker.modules.veToken
+  const lockerAddress = locker.modules.locker
+
+  const veBoost = locker.veBoost!
+  const secondaryMarket = locker.secondaryMarket!
+  const rewards = locker.rewards
+
+  const now = Math.floor(Date.now() / 1000)
+  const lastWeek = Math.floor(now / ONE_WEEK) * ONE_WEEK
+  const pegBase = parseUnits(secondaryMarket?.pegBase?.toString() || '1', 18)
+
+  const format = (value: bigint) => formatUnits(value, locker.token.decimals)
+  const formatRes = (value: any) => format(getRes(value))
+
+  const calls: Call[] = [
+    /*********************************************************************************
+     *** Voting Escrow
+     *********************************************************************************/
+
+    // Token locked by the Locker
+    { address: votingEscrow, name: 'locked', params: [lockerAddress] },
+    // veToken Balance of the Locker
+    { address: votingEscrow, name: 'balanceOf', params: [lockerAddress] },
+    // Total token locked
+    { address: votingEscrow, name: 'supply' },
+    // Total veToken supply
+    { address: votingEscrow, name: 'totalSupply' },
+
+    /*********************************************************************************
+     *** Gauge
+     *********************************************************************************/
+
+    // Total sdToken staked
+    { address: gauge, name: 'totalSupply' },
+    // Gauge working supply
+    { address: gauge, name: 'working_supply' },
+
+    /*********************************************************************************
+     *** Token & sdToken
+     *********************************************************************************/
+
+    // Token balance not locked
+    { address: token, name: 'balanceOf', params: [depositor] },
+    // sdToken in secondary market pool
+    { address: sdToken, name: 'balanceOf', params: [secondaryMarket.router] },
+
+    /*********************************************************************************
+     *** Peg
+     *********************************************************************************/
+
+    // Return amount when swapping {pegBase} sdToken to token -> get_dy(int128,int128,uint256)
+    {
+      address: contracts.balancerVault![1]!,
+      name: 'queryBatchSwap',
+      params: [
+        Zero,
+        [[secondaryMarket.pool, Zero, One, pegBase, '0x']],
+        [sdToken, token],
+        [zeroAddress, false, zeroAddress, false],
+      ],
+    },
+
+    /*********************************************************************************
+     *** Rewards
+     *********************************************************************************/
+
+    // Streaming status for each reward token
+    ...rewards.map((r) => ({ address: gauge, name: 'reward_data', params: [r.address] })),
+
+    /*********************************************************************************
+     *** veBoost
+     *********************************************************************************/
+
+    // Total veBoost delegated through delegator
+    { address: veBoost.delegator, name: 'totalSupply' },
+    // veBoost 5 last weeks rewards
+    ...range(0, 5).map((i) => ({
+      address: veBoost.delegator,
+      name: 'weeklyRewards',
+      params: [token, lastWeek - i * ONE_WEEK],
+    })),
+  ]
+
+  const res = await multicall(provider, calls, lockersMulticallAbi(locker.id, locker.chainId))
+  const raw = {
+    tokenLocked: getRes(res.shift()),
+    veBalanceOfLocker: formatRes(res.shift()),
+    totalTokenLocked: formatRes(res.shift()),
+    veTotalSupply: formatRes(res.shift()),
+    totalSupplyStaked: formatRes(res.shift()),
+    gaugeWorkingSupply: formatRes(res.shift()),
+    amountTokenNotLock: formatRes(res.shift()),
+    sdTokenInPool: formatRes(res.shift()),
+    peg: getRes(res.shift()),
+    rewards: rewards.map(() => getRes(res.shift())),
+    veBoost: {
+      delegated: formatRes(res.shift()),
+      weeklyRewards: range(0, 5).map(() => getRes(res.shift())),
+    },
+    veTokenRate: '4',
+    _workingSupply: '0',
+    _veBalanceOfLocker: '0',
+  }
+
+  raw.tokenLocked = format(raw.tokenLocked[0])
+  raw.peg = parsePeg(locker, raw.peg[1] * BigInt(-1))
+  raw._workingSupply = raw.gaugeWorkingSupply
+  raw._veBalanceOfLocker = raw.veBalanceOfLocker
+
+  return parse({ locker, common, prices, raw })
+}
+
+export default balancerLocker