@stake-dao/reader 0.1.0

package/src/strategies/curve/fetch/index.ts

@@ -0,0 +1,276 @@
+import { formatUnits } from 'viem'
+
+import { ONE_YEAR, curveStrats, mainnet, tokenWithId } from '@stake-dao/constants'
+import { equalTlc } from '../../../utils.js'
+import type { OnlyBoostData, RewardsData, SdtApr } from '../../types.js'
+import { getBoost } from '../../utils/boost.js'
+import decodeEtherscanFactoryEvent, { decodeNewFactoryEvent } from '../../utils/decodeEtherscanFactoryEvent.js'
+import { OneEther, Zero } from '../../utils/index.js'
+import { type SdtEmissionData, computeSdtApr } from '../../utils/sdt.js'
+import { buildCurveStrategies } from '../build.js'
+import { getCurveHttpCalls } from '../httpCalls.js'
+import { getOnChainSdCurveData } from '../onChainCalls.js'
+import type { GaugesWeightsData } from './curveApiData/getGaugesWeights.js'
+import { getAprBreakdown } from './getAprBreakdown.js'
+import { getCvxApr } from './getCvxApr.js'
+import getOnlyboostData from './getOnlyboostData.js'
+import { getCurveLendingWithApr, getCurveStratsWithApr } from './getStratsWithApr.js'
+import type { StratGlobalData } from './types.js'
+
+export const fetchCurve = async (
+  prices: any, // TODO Type
+  provider: any,
+  rpc: string,
+  explorerApiKey: string,
+  explorer: string,
+  chainId: number,
+  lastBlockNumber: number,
+  sdtEmissionData: SdtEmissionData,
+  gaugesWeights: GaugesWeightsData,
+) => {
+  const apisData = await getCurveHttpCalls(explorerApiKey, explorer, rpc, chainId, lastBlockNumber, gaugesWeights)
+
+  const newVaultAndLp =
+    chainId === mainnet.id
+      ? decodeNewFactoryEvent(apisData.explorerData)
+      : decodeEtherscanFactoryEvent(apisData.explorerData)
+
+  const allVaultAndLp = curveStrats.strats[chainId]!.concat(newVaultAndLp)
+
+  const strats: any[] = await buildCurveStrategies(provider, allVaultAndLp, chainId, apisData.curveApiData)
+
+  const { curveStratsWithApr, curveStratsDataCalls } = getCurveStratsWithApr(chainId, strats, apisData)
+  const { curveLendingWithApr, curveLendingDataCalls } = await getCurveLendingWithApr(
+    provider,
+    chainId,
+    strats,
+    apisData,
+  )
+
+  const stratsWithApr = [...curveStratsWithApr, ...curveLendingWithApr]
+  const stratsDataCalls = [...curveStratsDataCalls, ...curveLendingDataCalls]
+
+  const decodedPromise = await getOnChainSdCurveData(chainId, rpc, stratsDataCalls)
+
+  const global: StratGlobalData = {
+    totalGaugeWeights: '0',
+    nextEffectiveTimestamp: '0',
+    cvxTotalSupply: '0',
+    veCrvTotalSupply: '0',
+    stakeDaoVeBoost: '0',
+    convexVeBoost: '0',
+    fees: {
+      veSdt: 0,
+      perf: 0,
+      accumulator: 0,
+      claimer: 0,
+    },
+  }
+
+  // TODO stratsData type
+  let stratsData: any[] = []
+
+  const crv = tokenWithId('crv', chainId)
+  decodedPromise.forEach((d: any, index: number) => {
+    if (index === 0 && chainId === mainnet.id) {
+      global.totalGaugeWeights = formatUnits(d.totalGaugeWeights, 0)
+      global.nextEffectiveTimestamp = formatUnits(d.nextEffectiveTimestamp, 0)
+      global.cvxTotalSupply = formatUnits(d.cvxTotalSupply, 0)
+      global.veCrvTotalSupply = formatUnits(d.veCrvTotalSupply, 0)
+      global.stakeDaoVeBoost = formatUnits(d.stakeDaoVeBoost, 0)
+      global.convexVeBoost = formatUnits(d.convexVeBoost, 0)
+
+      global.fees = {
+        veSdt: 5,
+        perf: 2,
+        accumulator: 8,
+        claimer: Number(d.claimerFee) / 100,
+      }
+    }
+    const parsedData = d.curveStratsData.map((v: any) => {
+      const strat = stratsWithApr.find((s) => equalTlc(s.vault, v.vault))
+
+      let onlyboost: OnlyBoostData = {} as OnlyBoostData
+      let totalSupply = '0'
+      let boost = 2.5
+
+      if (chainId === mainnet.id && v.onlyboost.active) {
+        onlyboost = getOnlyboostData(
+          v.onlyboost,
+          global.stakeDaoVeBoost,
+          global.convexVeBoost,
+          global.veCrvTotalSupply,
+          v.curveGaugeTotalSupply,
+          v.strategyHoldings,
+          v.workingBalance,
+          v.totalSupply,
+          strat.lpPriceInUsd,
+        )
+        totalSupply = onlyboost.totalSupply
+        boost = onlyboost.boost
+      } else {
+        totalSupply = formatUnits(v.totalSupply, 0)
+        boost = getBoost('curve', v.strategyHoldings, v.workingBalance)
+      }
+
+      const tvl = Number(formatUnits(BigInt(totalSupply), 18)) * strat.lpPriceInUsd
+
+      const sdGauge = {
+        address: strat.sdGauge,
+        totalSupply: formatUnits(v.sdGaugeTotalSupply, 0),
+        ...(chainId === mainnet.id
+          ? {
+              relativeWeight: formatUnits(v.gaugeRelativeWeight, 0),
+              weight: formatUnits(v.gaugeWeight, 0),
+              futureWeight:
+                BigInt(global.totalGaugeWeights) > 0
+                  ? formatUnits(((v.gaugeWeight as bigint) * OneEther * OneEther) / BigInt(global.totalGaugeWeights), 0)
+                  : '0',
+              workingSupply: formatUnits(v.sdWorkingSupply, 0),
+            }
+          : { relativeWeight: '0', weight: '0', futureWeight: '0', workingSupply: '0' }),
+      }
+
+      const rewardsData: RewardsData[] = v.rewardsData.map((r: any, rewardIndex: number) => {
+        const rewardToken = strat.rewards[rewardIndex]
+        const rewardPrice = prices.find((p: any) => equalTlc(p.symbol, rewardToken.symbol))
+
+        const periodFinish = Number(formatUnits(r.period_finish, 0))
+        const streaming = periodFinish > Math.floor(Date.now() / 1000)
+
+        const rewardApr =
+          streaming && rewardPrice && tvl > 0
+            ? (Number(formatUnits(r.rate * BigInt(ONE_YEAR), 18)) * rewardPrice.usdPrice) /
+              tvl /
+              (equalTlc(rewardToken.symbol, 'SDT') ? 2.5 : 1)
+            : 0
+
+        return {
+          token: rewardToken,
+          price: rewardPrice ? rewardPrice.usdPrice : 0,
+          apr: rewardApr,
+          streaming,
+          periodFinish,
+          rate: formatUnits(r.rate, 0),
+          lastUpdate: formatUnits(r.last_update, 0),
+          claimablePendingRewards: equalTlc(v.rewardsTokens[rewardIndex], crv?.address!)
+            ? formatUnits(v.claimablePendingRewards, 0)
+            : formatUnits(
+                v.claimableData.find((c: any) => c.token === v.rewardsTokens[rewardIndex])?.claimable || Zero,
+                0,
+              ),
+        }
+      })
+
+      let sdtApr: SdtApr = {
+        sdtUserApr: 0,
+        sdtFuturUserApr: 0,
+        sdtMinApr: 0,
+        sdtFuturMinApr: 0,
+        sdtMaxApr: 0,
+        sdtFuturMaxApr: 0,
+        sdtBoost: 1,
+      }
+      const sdtRewards = rewardsData.find((r) => r.token.symbol === 'SDT')
+      if (sdtRewards) {
+        sdtApr = computeSdtApr(sdtEmissionData, sdtRewards, undefined, sdGauge, strat.lpPriceInUsd)
+      }
+
+      let convexCrvProjectedApr = 0
+      let cvxApr = 0
+
+      if (onlyboost.active) {
+        convexCrvProjectedApr = onlyboost.convex.boost * strat.minApr
+        cvxApr =
+          onlyboost.active && onlyboost.convex.tvl > 0
+            ? getCvxApr(
+                onlyboost.convex.tvl,
+                tvl,
+                convexCrvProjectedApr,
+                global.cvxTotalSupply,
+                prices.find((p: any) => equalTlc(p.symbol, 'CVX'))?.usdPrice || 0,
+              )
+            : 0
+      }
+
+      const apr = getAprBreakdown(strat, rewardsData, boost, cvxApr, sdtApr)
+
+      return {
+        ...strat,
+        tvl,
+        apr: {
+          boost,
+          ...apr,
+          ...(onlyboost?.active
+            ? {
+                onlyboost: {
+                  convex: {
+                    projected: {
+                      baseToken: strat.minApr ? onlyboost.convex.boost * strat.minApr : undefined,
+                    },
+                  },
+                  optimal: {
+                    projected: {
+                      baseToken: strat.minApr ? onlyboost.optimalBoost * strat.minApr : undefined,
+                    },
+                  },
+                },
+              }
+            : {}),
+        },
+        sdtApr,
+        rewards: rewardsData,
+
+        vaultHoldings: formatUnits(v.vaultHoldings, 0),
+        totalSupply,
+        strategyHoldings: formatUnits(v.strategyHoldings, 0),
+        workingBalance: formatUnits(v.workingBalance, 0),
+        workingSupplyStaked: formatUnits(v.workingSupplyStaked, 0),
+        sdGauge,
+        vaultFees:
+          chainId === mainnet.id
+            ? {
+                keeper: Number(v.keeperFee) / 100,
+                accumulated: formatUnits(v.accumulatedFees, 0),
+              }
+            : { keeper: 0, accumulated: '0' },
+        // onlyboost
+        ...(chainId === mainnet.id && onlyboost?.active ? { onlyboost } : {}),
+      }
+    })
+    stratsData = stratsData.concat(parsedData)
+  })
+
+  // const deployedStratsGauges = stratsData.map((s) => s.gaugeAddress)
+
+  // const notDeployedStrats = apisData.curveApiData
+  //   .flatMap((d) => d.value)
+  //   .filter(
+  //     (curvePool) =>
+  //       curvePool?.gaugeAddress &&
+  //       !deployedStratsGauges.includes(curvePool.gaugeAddress) &&
+  //       ((curvePool.gaugeCrvApy &&
+  //         curvePool.gaugeCrvApy.length > 1 &&
+  //         curvePool.gaugeCrvApy[1] !== null &&
+  //         curvePool.gaugeCrvApy[1] > 0) ||
+  //         (curvePool.gaugeRewards && curvePool.gaugeRewards.length > 0)),
+  //   )
+  //   .map((s) => ({
+  //     ...s,
+  //     protocol: 'curve',
+  //     chainId,
+  //     convexPool:
+  //       chainId === 1
+  //         ? apisData.convexPools.find(
+  //             (pool: any) => pool.lpTokenAddress.toLowerCase() === s.lpTokenAddress.toLowerCase(),
+  //           )?.convexPoolData || undefined
+  //         : undefined,
+  //   }))
+
+  return {
+    global,
+    deployed: stratsData,
+    notDeployed: [],
+    fetched: true,
+  }
+}

package/src/strategies/curve/fetch/types.ts

@@ -0,0 +1,11 @@
+import type { Fees } from '../../types.js'
+
+export type StratGlobalData = {
+  totalGaugeWeights: string
+  nextEffectiveTimestamp: string
+  cvxTotalSupply: string
+  veCrvTotalSupply: string
+  stakeDaoVeBoost: string
+  convexVeBoost: string
+  fees: Fees
+}

package/src/strategies/curve/httpCalls.ts

@@ -0,0 +1,117 @@
+import { contract } from '@stake-dao/constants'
+import {
+  CONVEX_LENDING_VAULTS_URL,
+  CONVEX_POOLS_URL,
+  CURVE_API_URL,
+  FACTORY_EXPLORER_EVENTS,
+  NEW_FACTORY_EXPLORER_EVENTS,
+} from './endpoints.js'
+import { fetchCurveBase } from './fetch/curveApiData/getCurveApiData.js'
+import { type GaugesWeightsData } from './fetch/curveApiData/getGaugesWeights.js'
+
+export const getCurveHttpCalls = async (
+  explorerApiKey: string,
+  explorer: string,
+  rpc: string,
+  chainId: number,
+  lastBlockNumber: number,
+  gaugesWeights: GaugesWeightsData,
+) => {
+  switch (chainId) {
+    case 1: {
+      const ethHttpCalls = [
+        // Etherscan Events
+        (
+          await fetch(
+            NEW_FACTORY_EXPLORER_EVENTS(
+              explorerApiKey,
+              explorer,
+              contract('curveVaultFactory', chainId),
+              lastBlockNumber,
+            ),
+          )
+        ).json(),
+        // Curve Data (replace APIs calls)
+        fetchCurveBase(rpc, chainId, gaugesWeights.gauges),
+        // Curve Trading Apy API
+        (await fetch(`${CURVE_API_URL}/getSubgraphData/ethereum`)).json(),
+        // Convex API for OnlyBoost
+        (await fetch(CONVEX_POOLS_URL)).json(),
+        (await fetch(CONVEX_LENDING_VAULTS_URL)).json(),
+      ]
+
+      const ethHttpResponses = (await Promise.allSettled(ethHttpCalls)).map((result) =>
+        result.status === 'fulfilled' ? result.value : result.reason,
+      )
+
+      const etherscanData = ethHttpResponses[0]
+      const ethCurveData = ethHttpResponses[1]
+      const ethCurveSubgraph = ethHttpResponses[2].success ? ethHttpResponses[2].data.poolList : undefined
+      const convexPools = ethHttpResponses[3].pools
+      const convexLendingVaults = ethHttpResponses[4].lendingVaults
+
+      return {
+        explorerData: etherscanData,
+        curveSubgraphData: ethCurveSubgraph,
+        convexPools,
+        convexLendingVaults,
+        curveApiData: ethCurveData,
+      }
+    }
+    case 42161: {
+      const arbitrumHttpCalls = [
+        // Etherscan Events
+        (
+          await fetch(
+            FACTORY_EXPLORER_EVENTS(explorerApiKey, explorer, contract('curveVaultFactory', chainId), lastBlockNumber),
+          )
+        ).json(),
+        // Curve Apis
+        (await fetch(`${CURVE_API_URL}/getPools/arbitrum/factory`)).json(),
+        (await fetch(`${CURVE_API_URL}/getPools/arbitrum/main`)).json(),
+        (await fetch(`${CURVE_API_URL}/getPools/arbitrum/crypto`)).json(),
+        (await fetch(`${CURVE_API_URL}/getPools/arbitrum/factory-stable-ng`)).json(),
+        (await fetch(`${CURVE_API_URL}/getPools/arbitrum/factory-tricrypto`)).json(),
+        (await fetch(`${CURVE_API_URL}/getSubgraphData/arbitrum`)).json(),
+      ]
+
+      const arbitrumHttpResponses = (await Promise.allSettled(arbitrumHttpCalls)).map((result) =>
+        result.status === 'fulfilled' ? result.value : result.reason,
+      )
+
+      const arbiscanData = arbitrumHttpResponses[0]
+      const arbitrumCurveFactory = arbitrumHttpResponses[1].success ? arbitrumHttpResponses[1].data.poolData : undefined
+      const arbitrumCurveMain = arbitrumHttpResponses[2].success ? arbitrumHttpResponses[2].data.poolData : undefined
+      const arbitrumCurveCrypto = arbitrumHttpResponses[3].success ? arbitrumHttpResponses[3].data.poolData : undefined
+      const arbitrumCurveFactoryStableNg = arbitrumHttpResponses[4].success
+        ? arbitrumHttpResponses[4].data.poolData
+        : undefined
+      const arbitrumCurveFactoryTriCrypto = arbitrumHttpResponses[5].success
+        ? arbitrumHttpResponses[5].data.poolData
+        : undefined
+      const arbitrumCurveSubgraph = arbitrumHttpResponses[6].success
+        ? arbitrumHttpResponses[6].data.poolList
+        : undefined
+
+      return {
+        explorerData: arbiscanData,
+        curveSubgraphData: arbitrumCurveSubgraph,
+        convexPools: [],
+        curveApiData: [
+          { type: 'factory-tricrypto', value: arbitrumCurveFactoryTriCrypto },
+          { type: 'factory', value: arbitrumCurveFactory },
+          { type: 'main', value: arbitrumCurveMain },
+          { type: 'crypto', value: arbitrumCurveCrypto },
+          { type: 'factory-stable-ng', value: arbitrumCurveFactoryStableNg },
+        ],
+      }
+    }
+  }
+
+  return {
+    explorerData: undefined,
+    curveSubgraphData: undefined,
+    convexPools: [],
+    curveApiData: [],
+  }
+}

package/src/strategies/curve/onChainCalls.ts

@@ -0,0 +1,36 @@
+import { contract, mainnet } from '@stake-dao/constants'
+import { chunk } from 'lodash-es'
+import { encodeAbiParameters, parseAbiParameters } from 'viem'
+import { batchCurveStrats } from '../../batches/index.js'
+import { batchJsonRpc } from '../../utils.js'
+
+export const getOnChainSdCurveData = async (chainId: number, rpc: string, calls: any[]) => {
+  const inputArgsChunks = chunk(calls, 12)
+
+  const allContractCreationCodes: string[] = inputArgsChunks.map((inputArgs) => {
+    const inputParams =
+      chainId === mainnet.id
+        ? [
+            contract('convexProxyFactory', chainId),
+            contract('curveStrategy', chainId),
+            contract('sdGaugeController', chainId),
+            inputArgs,
+          ]
+        : [contract('curveStratsFeeRegistry', chainId), inputArgs]
+
+    const inputData = encodeAbiParameters(
+      parseAbiParameters(batchCurveStrats.inputType[chainId] || []) as any,
+      inputParams,
+    )
+    return batchCurveStrats.bytecode[chainId]?.concat(inputData.slice(2)) as string
+  })
+
+  const decodedPromise = await batchJsonRpc({
+    rpc,
+    calls: allContractCreationCodes,
+    outputTypeAbi: batchCurveStrats.outputType ? batchCurveStrats.outputType[chainId] : [],
+    parse: false,
+  })
+
+  return decodedPromise
+}

package/src/strategies/types.ts

@@ -0,0 +1,137 @@
+export type Coin = {
+  name: string
+  symbol: string
+  address: string
+  decimals: number
+}
+
+export type AprDetail = {
+  total: number
+  details: {
+    label: string
+    value: number[]
+  }[]
+}
+
+export type OnlyBoostAprDetail = {
+  projected: {
+    baseToken: number
+  }
+}
+
+export type OnlyBoostProtocolData = {
+  tvl: number
+  supply: string
+  boost: number
+  optimal: {
+    supply: string
+    boost: number
+    share: number
+  }
+  claimable?: {
+    token: string
+    claimable: string
+  }[]
+}
+
+export type OnlyBoostData = {
+  active: boolean
+  implementations: {
+    key: string
+    address: string
+  }[]
+  totalSupply: string
+  boost: number
+  optimalBoost: number
+  stakeDao: OnlyBoostProtocolData
+  convex: OnlyBoostProtocolData
+}
+
+export type SdGauge = {
+  address: string
+  totalSupply: string
+  relativeWeight: string
+  weight: string
+  futureWeight: string
+  workingSupply: string
+}
+
+export type Fees = {
+  veSdt: number
+  perf: number
+  accumulator: number
+  claimer: number
+}
+
+export type VaultFees = {
+  keeper: number
+  accumulated: number
+}
+
+export type SdtApr = {
+  sdtUserApr: number
+  sdtFuturUserApr: number
+  sdtMinApr: number
+  sdtFuturMinApr: number
+  sdtMaxApr: number
+  sdtFuturMaxApr: number
+  sdtBoost: number
+}
+
+export type RewardsData = {
+  token: Coin
+  price: number
+  apr: number
+  streaming: boolean
+  periodFinish: number
+  rate: string
+  lastUpdate: string
+  claimablePendingRewards: string
+}
+
+export type Strategy = {
+  key: string
+  type: string
+  protocol: string
+  chainId: number
+  isMetapool: boolean
+  isLending: boolean
+  vault: string
+  lpToken: Coin
+  gaugeAddress: string
+  coins: Coin[]
+  underlyingCoins?: Coin[]
+  rewards: RewardsData[]
+  name: string
+  minApr: number
+  maxApr: number
+  lpPriceInUsd: number
+  convexPool?: {
+    id: number
+    token: string
+    gauge: string
+    crvRewards: string
+    stash: string
+    shutdown: boolean
+    usdTotal: number
+  }
+  tvl: number
+  apr: {
+    boost: number
+    current: AprDetail
+    projected: AprDetail
+    onlyboost: {
+      convex: OnlyBoostAprDetail
+      optimal: OnlyBoostAprDetail
+    }
+  }
+  sdtApr: SdtApr
+  vaultHoldings: string
+  totalSupply: string
+  strategyHoldings: string
+  workingBalance: string
+  workingSupplyStaked: string
+  sdGauge: SdGauge
+  vaultFees: VaultFees
+  onlyboost?: OnlyBoostData | { active: boolean }
+}

package/src/strategies/utils/boost.ts

@@ -0,0 +1,41 @@
+import { formatUnits } from 'viem'
+import { OneEther, Zero } from './index.js'
+
+export const getBoost = (protocol: string, strategyHoldings: bigint, workingBalance: bigint): number => {
+  switch (protocol) {
+    case 'curve':
+      return Number(
+        strategyHoldings > Zero
+          ? formatUnits((workingBalance * OneEther) / ((strategyHoldings * BigInt(4)) / BigInt(10)), 18)
+          : '2.5',
+      )
+    case 'balancer':
+      return Number(
+        strategyHoldings > Zero
+          ? formatUnits((workingBalance * OneEther) / ((strategyHoldings * BigInt(4)) / BigInt(10)), 18)
+          : '1',
+      )
+    case 'angle':
+      return Number(
+        strategyHoldings > Zero
+          ? formatUnits((workingBalance * OneEther) / ((strategyHoldings * BigInt(4)) / BigInt(10)), 18)
+          : '1',
+      )
+    case 'pendle':
+      return Number(
+        strategyHoldings > Zero
+          ? formatUnits((workingBalance * OneEther) / ((strategyHoldings * BigInt(4)) / BigInt(10)), 18)
+          : '2.5',
+      )
+    case 'yearn':
+      return Number(
+        strategyHoldings > Zero
+          ? Math.min(1, Number(formatUnits((workingBalance * OneEther) / strategyHoldings, 18))) * 10
+          : '10',
+      )
+    default:
+      break
+  }
+
+  return 0
+}

package/src/strategies/utils/decodeEtherscanFactoryEvent.ts

@@ -0,0 +1,42 @@
+import { decodeEventLog, parseAbiItem } from 'viem'
+
+const decodeEtherscanFactoryEvent = (explorerData: any, onlyVault: boolean = false) => {
+  return explorerData.status === '1' && explorerData.result
+    ? explorerData.result.map((event: any) => {
+        const decodedData = decodeEventLog({
+          abi: [
+            parseAbiItem('event VaultDeployed(address proxy, address lpToken, address impl)'),
+            ...(onlyVault ? [] : [parseAbiItem('event GaugeDeployed(address proxy, address lpToken, address impl)')]),
+          ],
+          data: event.data,
+          topics: event.topics,
+        })
+        return {
+          vault: decodedData.args.proxy,
+          lpToken: decodedData.args.lpToken,
+        }
+      })
+    : []
+}
+
+export const decodeNewFactoryEvent = (explorerData: any) => {
+  return explorerData.status === '1' && explorerData.result
+    ? explorerData.result.map((event: any) => {
+        const decodedData = decodeEventLog({
+          abi: [
+            parseAbiItem('event PoolDeployed(address vault, address rewardDistributor, address token, address gauge)'),
+          ],
+          data: event.data,
+          topics: event.topics,
+        })
+        return {
+          vault: decodedData.args.vault,
+          sdGauge: decodedData.args.rewardDistributor,
+          lpToken: decodedData.args.token,
+          gauge: decodedData.args.gauge,
+        }
+      })
+    : []
+}
+
+export default decodeEtherscanFactoryEvent

package/src/strategies/utils/index.ts

@@ -0,0 +1,8 @@
+import { parseEther } from 'viem'
+
+export const Zero = BigInt(0)
+export const OneEther = parseEther('1')
+
+export * from './boost.js'
+export * from './decodeEtherscanFactoryEvent.js'
+export * from './sdt.js'

package/src/strategies/utils/promise.ts

@@ -0,0 +1,10 @@
+export const handlePromise = async (promises: Promise<any>[], key: string) => {
+  const promisesResults = await Promise.allSettled(promises)
+
+  return promisesResults.map((pr, index) => {
+    if (pr.status === 'rejected') {
+      throw Error(`${key}: promise error index ${index}\n${pr.reason}`)
+    }
+    return pr.value
+  })
+}