@stake-dao/reader 0.5.35 → 0.5.37

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

@@ -1,157 +0,0 @@
-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/strategies/angle/endpoints.ts

@@ -1,2 +0,0 @@
-export const ANGLE_APR_URL = 'https://api.angle.money/v1/apr'
-export const ANGLE_PRICE_URL = 'https://api.angle.money/v1/prices'

package/src/strategies/angle/fetch.ts

@@ -1,253 +0,0 @@
-import { STRAT_FEES, Zero, angleStrats, contracts } from '@stake-dao/constants'
-import { chunk, uniq } from 'lodash-es'
-import { encodeAbiParameters, formatUnits, parseAbiParameters } from 'viem'
-import { mainnet } from 'viem/chains'
-import multicallAngleVaultsAbi from '../../abis/angleVaultsMulticall.js'
-import { batchAngleStrats } from '../../bytecodes/index.js'
-import { type Price, getPricesFromLlama } from '../../prices.js'
-import { batchJsonRpc, equalTlc, multicall } from '../../utils.js'
-import type { RewardsData, SdtApr } from '../types.js'
-import { getAprBreakdown } from '../utils/getAprBreakdown.js'
-import getTokenTypes from '../utils/getTokenTypes.js'
-import { ANGLE_APR_URL, ANGLE_PRICE_URL } from './endpoints.js'
-
-interface TFetchAngle {
-  prices: Price[]
-  provider: any
-  rpc: string
-  chainId: number
-}
-
-export const fetchAngle = async ({ prices, provider, rpc, chainId }: TFetchAngle) => {
-  const stratsDataCalls: { vault: string; token: string; sdtLiquidityGauge: string }[] = []
-  const balancesCalls: { address: string; name: string }[] = []
-  const dataCalls: { address: string; name: string }[] = []
-
-  const strats = angleStrats.strats[chainId].filter((s) => s.chainId === chainId)
-
-  const tokensToFetch: any = []
-
-  for (const s of strats) {
-    tokensToFetch.push(...s.underlyingCoins)
-    if (s.lpToken.symbol !== 'SLP') {
-      balancesCalls.push(
-        ...[
-          {
-            address: s.lpToken.address,
-            name: s.key.includes('gamma') ? 'getTotalAmounts' : 'getUnderlyingBalances',
-          },
-          {
-            address: s.lpToken.address,
-            name: 'totalSupply',
-          },
-        ],
-      )
-    }
-    dataCalls.push(
-      ...[
-        { address: s.vault, name: 'totalSupply' },
-        { address: s.rewards[0].gauge, name: 'totalSupply' },
-        { address: s.rewards[0].gauge, name: 'working_supply' },
-      ],
-    )
-  }
-
-  const httpCalls = [
-    // Angle APR
-    (await fetch(ANGLE_APR_URL)).json(),
-    // Angle Prices
-    (await fetch(ANGLE_PRICE_URL)).json(),
-    // Defillama prices
-    await getPricesFromLlama(uniq(tokensToFetch), chainId),
-  ]
-
-  const httpResponses = await Promise.all(httpCalls)
-
-  const rawBalances: any = await multicall(provider, balancesCalls, multicallAngleVaultsAbi)
-  const rawData: any = await multicall(provider, dataCalls, multicallAngleVaultsAbi)
-
-  const angleAprData = httpResponses[0]
-  const anglePriceData = httpResponses[1]
-  const defillamaPrices = httpResponses[2]
-
-  let rawPriceIndex = 0
-  const stratsWithApy = strats.map((s) => {
-    const aprData = angleAprData[s.aprApiKey]
-    let priceData = anglePriceData.find((d) => d.token === s.aprApiKey)
-
-    if (!priceData) {
-      const token0 = s.underlyingCoins[0]
-      const token1 = s.underlyingCoins[1]
-      const token0Price = defillamaPrices.find((p) => p.symbol === token0.symbol)
-      const token1Price = defillamaPrices.find((p) => p.symbol === token1.symbol)
-      const token0AmountUsd =
-        Number(formatUnits(rawBalances[rawPriceIndex].result[0], token0.decimals)) * token0Price.usdPrice
-      const token1AmountUsd =
-        Number(formatUnits(rawBalances[rawPriceIndex].result[1], token1.decimals)) * token1Price.usdPrice
-      const totalLp = Number(formatUnits(rawBalances[rawPriceIndex + 1].result, 18))
-      const lpPriceInUsd = (token0AmountUsd + token1AmountUsd) / totalLp
-
-      priceData = { rate: lpPriceInUsd }
-
-      rawPriceIndex += 2
-    }
-
-    let maxApr = 0
-    let tradingApy = 0
-
-    if (aprData?.details && aprData.value && aprData.address) {
-      tradingApy = aprData.details.fees ? aprData.details.fees : 0
-      const aprDetailsKeys = Object.keys(aprData.details)
-      const indexOfApy = aprDetailsKeys.map((k) => k.includes(s.lpToken.address.toLowerCase())).indexOf(true)
-      maxApr =
-        indexOfApy > 0
-          ? aprData.details[aprDetailsKeys[indexOfApy]!]
-          : aprData.details.max
-            ? aprData.details.max
-            : aprData.value - tradingApy
-    }
-
-    if (s.key === 'angle-sushi-eura-angle') {
-      stratsDataCalls.push({
-        vault: s.vault,
-        token: s.lpToken.address,
-        sdtLiquidityGauge: s.gaugeAddress,
-      })
-    }
-
-    return {
-      ...s,
-      tradingApy,
-      minApr: (maxApr * ((100 - STRAT_FEES) / 100)) / 2.5,
-      maxApr: maxApr * ((100 - STRAT_FEES) / 100),
-      lpPriceInUsd: priceData ? priceData.rate : 1,
-    }
-  })
-
-  const inputArgsChunks = chunk(stratsDataCalls, 20)
-  const angleCalls = inputArgsChunks.map((inputArgs) => {
-    const inputData = encodeAbiParameters(parseAbiParameters(batchAngleStrats.inputType[chainId]!) as any, [
-      contracts.sdGaugeController![chainId],
-      inputArgs,
-    ])
-    return batchAngleStrats.bytecode[chainId]!.concat(inputData.slice(2))
-  })
-
-  const rawAngleData = await batchJsonRpc({
-    rpc,
-    calls: angleCalls,
-    outputTypeAbi: batchAngleStrats.outputTypeHr[chainId],
-    callsKey: `strategies/angle/fetch.ts: rawAngleData - chainId ${chainId} - rpc ${rpc}`,
-  })
-
-  let offchainDataIndex = 0
-  const parsedStrats = stratsWithApy.map((s) => {
-    let fetchedData: any
-
-    if (s.offchain) {
-      fetchedData = {
-        totalSupply: rawData[offchainDataIndex].result,
-        sdGaugeTotalSupply: rawData[offchainDataIndex + 1].result,
-        sdWorkingSupply: chainId === mainnet.id ? rawData[offchainDataIndex + 2].result : Zero,
-        accumulatedFees: Zero,
-        keeperFee: Zero,
-      }
-    } else {
-      fetchedData = rawAngleData.shift()
-    }
-
-    offchainDataIndex += 3
-
-    const rewardsData: RewardsData[] = s.rewards.map((r: any) => {
-      const rewardToken = {
-        symbol: r.symbol,
-        name: r.name,
-        decimals: r.decimals,
-        address: r.address,
-      }
-      const rewardPrice = prices.find((p: any) => equalTlc(p.address, rewardToken.address))
-
-      return {
-        token: rewardToken,
-        price: rewardPrice ? rewardPrice.usdPrice : 0,
-        apr: 0,
-        streaming: false,
-        periodFinish: 0,
-        rate: '0',
-        lastUpdate: '0',
-        claimablePendingRewards: '0',
-      }
-    })
-
-    const boost = 2.5
-    const sdtApr: SdtApr = {
-      sdtUserApr: 0,
-      sdtFuturUserApr: 0,
-      sdtMinApr: 0,
-      sdtFuturMinApr: 0,
-      sdtMaxApr: 0,
-      sdtFuturMaxApr: 0,
-      sdtBoost: 1,
-    }
-    const apr = getAprBreakdown(s, rewardsData, boost, sdtApr)
-
-    const totalSupply = formatUnits(fetchedData.totalSupply, 0)
-    const lpPriceInUsd = s.lpPriceInUsd
-    const tvl = lpPriceInUsd * Number(formatUnits(BigInt(fetchedData.totalSupply), 18))
-
-    const sdGauge = {
-      address: s.gaugeAddress,
-      totalSupply: formatUnits(fetchedData.sdGaugeTotalSupply, 0),
-      relativeWeight: '0',
-      weight: '0',
-      futureWeight: '0',
-      workingSupply: '0',
-    }
-
-    return {
-      key: s.key,
-      name: s.name,
-      tokensFilter: getTokenTypes(s),
-      protocol: s.protocol,
-      chainId: s.chainId,
-      vault: s.vault,
-      lpToken: s.lpToken,
-      gaugeAddress: s.gaugeAddress,
-      coins: s.coins,
-      sdGauge,
-      lpPriceInUsd,
-      streaming: rewardsData.some((r) => Number(r.periodFinish) > Math.floor(Date.now() / 1000)),
-      tvl,
-      apr: {
-        boost,
-        ...apr,
-      },
-      rewards: rewardsData,
-      // Base APR data
-      tradingApy: s.tradingApy,
-      minApr: s.minApr,
-      maxApr: s.maxApr,
-      // Raw data
-      totalSupply,
-      // Gas optimised
-      vaultFees: {
-        keeper: Number(fetchedData.keeperFee) / 100,
-        accumulated: formatUnits(fetchedData.accumulatedFees, 0),
-      },
-    }
-  })
-
-  return {
-    global: {
-      fees: {
-        veSdt: 5,
-        perf: 2,
-        accumulator: 8,
-        claimer: 0.5,
-      },
-    },
-    deployed: parsedStrats,
-    notDeployed: [],
-    fetched: true,
-  }
-}