fixed bonus rewards apr by considering sponsored supply

packages/hyperstructure-client-js/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@generationsoftware/hyperstructure-client-js",
   "description": "Lightweight library for interacting with PoolTogether contracts",
-  "version": "1.19.0",
+  "version": "1.20.0",
   "license": "MIT",
   "main": "./dist/index.mjs",
   "types": "./dist/index.d.ts",

packages/hyperstructure-client-js/src/Vault.ts

@@ -486,6 +486,26 @@ export class Vault {
     return this.owner
   }
 
+  /**
+   * Returns the vault's total delegate supply (total supply - sponsored supply)
+   * @returns
+   */
+  async getTotalDelegateSupply(): Promise<bigint> {
+    const source = 'Vault [getTotalDelegateSupply]'
+    await validateClientNetwork(this.chainId, this.publicClient, source)
+
+    const twabControllerAddress = await this.getTWABController()
+
+    const totalDelegateSupply = await this.publicClient.readContract({
+      address: twabControllerAddress,
+      abi: twabControllerABI,
+      functionName: 'totalSupplyDelegateBalance',
+      args: [this.address]
+    })
+
+    return totalDelegateSupply
+  }
+
   /* ============================== Write Functions ============================== */
 
   /**

packages/hyperstructure-client-js/src/Vaults.ts

@@ -9,6 +9,7 @@ import {
   getVaultExchangeRates,
   getVaultId,
   getVaultsByChainId,
+  getVaultTotalDelegateSupplies,
   getVaultUnderlyingTokenAddresses,
   validateAddress,
   validateClientNetwork
@@ -437,4 +438,42 @@ export class Vaults {
 
     return this.underlyingTokenAddresses
   }
+
+  /**
+   * Returns each vault's total delegate supply (total supply - sponsored supply)
+   * @returns
+   */
+  async getTotalDelegateSupplies(): Promise<{ [vaultId: string]: bigint }> {
+    const totalDelegateSupplies: { [vaultId: string]: bigint } = {}
+
+    await Promise.allSettled(
+      this.chainIds.map((chainId) =>
+        (async () => {
+          const vaultAddresses = this.vaultAddresses[chainId]
+          if (!!vaultAddresses?.length) {
+            const client = this.publicClients[chainId]
+            if (!!client) {
+              const source = `Vaults [getTotalDelegateSupplies] [${chainId}]`
+              await validateClientNetwork(chainId, client, source)
+              const chainVaults = getVaultsByChainId(chainId, this.allVaultInfo)
+              const twabControllerAddress = await this.vaults[
+                getVaultId({ chainId, address: vaultAddresses[0] })
+              ].getTWABController()
+              const chainTotalDelegateSupplies = await getVaultTotalDelegateSupplies(
+                client,
+                chainVaults,
+                twabControllerAddress
+              )
+
+              Object.keys(chainTotalDelegateSupplies).forEach((vaultId) => {
+                totalDelegateSupplies[vaultId] = chainTotalDelegateSupplies[vaultId]
+              })
+            }
+          }
+        })()
+      )
+    )
+
+    return totalDelegateSupplies
+  }
 }

packages/hyperstructure-react-hooks/README.md

@@ -173,6 +173,7 @@ yarn add @generationsoftware/hyperstructure-react-hooks
 - `useAllVaultTokenAddresses`
 - `useAllVaultTokenData`
 - `useAllVaultTokenPrices`
+- `useAllVaultTotalDelegateSupplies`
 - `useAllVaultTotalSupplyTwabs`
 - `useSortedVaults`
 - `useUserClaimableRewards`
@@ -199,7 +200,9 @@ yarn add @generationsoftware/hyperstructure-react-hooks
 - `useVaultTokenAddress`
 - `useVaultTokenData`
 - `useVaultTokenPrice`
+- `useVaultTotalDelegateSupply`
 - `useVaultTotalSupplyTwab`
+- `useVaultTwabController`
 - `useVaultYieldSource`
 
 ### Zap Hooks

packages/hyperstructure-react-hooks/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@generationsoftware/hyperstructure-react-hooks",
   "description": "React hooks library for interacting with PoolTogether contracts",
-  "version": "1.24.0",
+  "version": "1.25.0",
   "license": "MIT",
   "main": "./dist/index.mjs",
   "types": "./dist/index.d.ts",

packages/hyperstructure-react-hooks/src/constants.ts

@@ -68,6 +68,7 @@ export const QUERY_KEYS = {
   vaultShareData: 'vaultShareData',
   vaultTokenAddresses: 'vaultTokenAddresses',
   vaultTokenData: 'vaultTokenData',
+  vaultTotalDelegateSupplies: 'vaultTotalDelegateSupplies',
   vaultTotalSupplyTwabs: 'vaultTotalSupplyTwabs',
   vaultTwabController: 'vaultTwabController',
   vaultYieldSources: 'vaultYieldSources',

packages/hyperstructure-react-hooks/src/index.ts

@@ -138,6 +138,7 @@ export * from './vaults/useAllVaultSharePrices'
 export * from './vaults/useAllVaultTokenAddresses'
 export * from './vaults/useAllVaultTokenData'
 export * from './vaults/useAllVaultTokenPrices'
+export * from './vaults/useAllVaultTotalDelegateSupplies'
 export * from './vaults/useAllVaultTotalSupplyTwabs'
 export * from './vaults/useSortedVaults'
 export * from './vaults/useUserClaimableRewards'
@@ -164,6 +165,7 @@ export * from './vaults/useVaultSharePrice'
 export * from './vaults/useVaultTokenAddress'
 export * from './vaults/useVaultTokenData'
 export * from './vaults/useVaultTokenPrice'
+export * from './vaults/useVaultTotalDelegateSupply'
 export * from './vaults/useVaultTotalSupplyTwab'
 export * from './vaults/useVaultTwabController'
 export * from './vaults/useVaultYieldSource'

packages/hyperstructure-react-hooks/src/vaults/useAllVaultPromotionsApr.ts

@@ -3,7 +3,13 @@ import { TokenWithPrice } from '@shared/types'
 import { getSecondsSinceEpoch, lower, SECONDS_PER_YEAR } from '@shared/utilities'
 import { useMemo } from 'react'
 import { Address, formatUnits } from 'viem'
-import { useAllVaultPromotions, useAllVaultSharePrices, useTokenPrices, useTokens } from '..'
+import {
+  useAllVaultPromotions,
+  useAllVaultSharePrices,
+  useAllVaultTotalDelegateSupplies,
+  useTokenPrices,
+  useTokens
+} from '..'
 
 /**
  * Returns each vault's bonus rewards APR
@@ -52,6 +58,12 @@ export const useAllVaultPromotionsApr = (
     tokenAddresses
   )
 
+  const {
+    data: allTotalDelegateSupplies,
+    isFetched: isFetchedAllTotalDelegateSupplies,
+    refetch: refetchAllTotalDelegateSupplies
+  } = useAllVaultTotalDelegateSupplies(vaults)
+
   const data = useMemo(() => {
     const vaultPromotionAprs: { [vaultId: string]: number } = {}
 
@@ -60,21 +72,22 @@ export const useAllVaultPromotionsApr = (
       !!allVaultPromotions?.[chainId] &&
       !!allShareTokens &&
       !!rewardTokenPrices &&
-      !!rewardTokenData
+      !!rewardTokenData &&
+      !!allTotalDelegateSupplies
     ) {
       const currentTimestamp = getSecondsSinceEpoch()
 
       Object.values(vaults.vaults)
         .filter((vault) => vault.chainId === chainId)
         .forEach((vault) => {
           const shareToken = allShareTokens[vault.id]
+          const totalDelegateSupply = allTotalDelegateSupplies[vault.id]
 
-          if (shareToken?.totalSupply === 0n || shareToken?.price === 0) {
+          if (totalDelegateSupply === 0n || shareToken?.price === 0) {
             vaultPromotionAprs[vault.id] = 0
-          } else if (!!shareToken?.price) {
+          } else if (!!totalDelegateSupply && !!shareToken?.price) {
             const tvl =
-              parseFloat(formatUnits(shareToken.totalSupply, shareToken.decimals)) *
-              shareToken.price
+              parseFloat(formatUnits(totalDelegateSupply, shareToken.decimals)) * shareToken.price
 
             tokenAddresses.forEach((address) => {
               const rewardToken: TokenWithPrice = {
@@ -129,17 +142,25 @@ export const useAllVaultPromotionsApr = (
     }
 
     return vaultPromotionAprs
-  }, [allVaultPromotions, allShareTokens, rewardTokenPrices, rewardTokenData])
+  }, [
+    allVaultPromotions,
+    allShareTokens,
+    rewardTokenPrices,
+    rewardTokenData,
+    allTotalDelegateSupplies
+  ])
 
   const isFetched =
     isFetchedAllVaultPromotions &&
     isFetchedAllShareTokens &&
     isFetchedRewardTokenPrices &&
-    isFetchedRewardTokenData
+    isFetchedRewardTokenData &&
+    isFetchedAllTotalDelegateSupplies
 
   const refetch = () => {
     refetchAllVaultPromotions()
     refetchAllShareTokens()
+    refetchAllTotalDelegateSupplies()
   }
 
   return { data, isFetched, refetch }

packages/hyperstructure-react-hooks/src/vaults/useAllVaultTotalDelegateSupplies.ts

@@ -0,0 +1,30 @@
+import { Vaults } from '@generationsoftware/hyperstructure-client-js'
+import { NO_REFETCH } from '@shared/generic-react-hooks'
+import { useQuery, useQueryClient } from '@tanstack/react-query'
+import { populateCachePerId } from '..'
+import { QUERY_KEYS } from '../constants'
+
+/**
+ * Returns each vault's total delegate supply (total supply - sponsored supply)
+ * @param vaults instance of the `Vaults` class
+ * @returns
+ */
+export const useAllVaultTotalDelegateSupplies = (vaults: Vaults) => {
+  const queryClient = useQueryClient()
+
+  const vaultIds = !!vaults ? Object.keys(vaults.vaults) : []
+  const getQueryKey = (val: (string | number)[]) => [QUERY_KEYS.vaultTotalDelegateSupplies, val]
+
+  return useQuery({
+    queryKey: getQueryKey(vaultIds),
+    queryFn: async () => {
+      const totalDelegateSupply = await vaults.getTotalDelegateSupplies()
+
+      populateCachePerId(queryClient, getQueryKey, totalDelegateSupply)
+
+      return totalDelegateSupply
+    },
+    enabled: !!vaults,
+    ...NO_REFETCH
+  })
+}

packages/hyperstructure-react-hooks/src/vaults/useVaultPromotionsApr.ts

@@ -3,7 +3,13 @@ import { TokenWithPrice } from '@shared/types'
 import { getSecondsSinceEpoch, lower, SECONDS_PER_YEAR } from '@shared/utilities'
 import { useMemo } from 'react'
 import { Address, formatUnits } from 'viem'
-import { useTokenPrices, useTokens, useVaultPromotions, useVaultSharePrice } from '..'
+import {
+  useTokenPrices,
+  useTokens,
+  useVaultPromotions,
+  useVaultSharePrice,
+  useVaultTotalDelegateSupply
+} from '..'
 
 /**
  * Returns a vault's bonus rewards APR
@@ -45,21 +51,27 @@ export const useVaultPromotionsApr = (
     tokenAddresses
   )
 
+  const {
+    data: totalDelegateSupply,
+    isFetched: isFetchedTotalDelegateSupply,
+    refetch: refetchTotalDelegateSupply
+  } = useVaultTotalDelegateSupply(vault)
+
   const data = useMemo(() => {
-    if (shareToken?.totalSupply === 0n || shareToken?.price === 0) {
+    if (totalDelegateSupply === 0n || shareToken?.price === 0) {
       return { apr: 0, tokens: [] }
     }
 
     if (
       !!vaultPromotions &&
-      !!shareToken &&
-      !!shareToken.price &&
+      !!shareToken?.price &&
       !!rewardTokenPrices &&
-      !!rewardTokenData
+      !!rewardTokenData &&
+      !!totalDelegateSupply
     ) {
       const currentTimestamp = getSecondsSinceEpoch()
       const tvl =
-        parseFloat(formatUnits(shareToken.totalSupply, shareToken.decimals)) * shareToken.price
+        parseFloat(formatUnits(totalDelegateSupply, shareToken.decimals)) * shareToken.price
 
       const relevantTokenAddresses = new Set<Address>()
       let apr = 0
@@ -116,17 +128,19 @@ export const useVaultPromotionsApr = (
 
       return { apr, tokens: promotionTokens }
     }
-  }, [vaultPromotions, shareToken, rewardTokenPrices, rewardTokenData])
+  }, [vaultPromotions, shareToken, rewardTokenPrices, rewardTokenData, totalDelegateSupply])
 
   const isFetched =
     isFetchedVaultPromotions &&
     isFetchedShareToken &&
     isFetchedRewardTokenPrices &&
-    isFetchedRewardTokenData
+    isFetchedRewardTokenData &&
+    isFetchedTotalDelegateSupply
 
   const refetch = () => {
     refetchVaultPromotions()
     refetchShareToken()
+    refetchTotalDelegateSupply()
   }
 
   return { data, isFetched, refetch }

packages/hyperstructure-react-hooks/src/vaults/useVaultTotalDelegateSupply.ts

@@ -0,0 +1,20 @@
+import { Vault } from '@generationsoftware/hyperstructure-client-js'
+import { NO_REFETCH } from '@shared/generic-react-hooks'
+import { useQuery, UseQueryResult } from '@tanstack/react-query'
+import { QUERY_KEYS } from '../constants'
+
+/**
+ * Returns the vault's total delegate supply (total supply - sponsored supply)
+ * @param vault instance of the `Vault` class
+ * @returns
+ */
+export const useVaultTotalDelegateSupply = (vault: Vault): UseQueryResult<bigint> => {
+  const queryKey = [QUERY_KEYS.vaultTotalDelegateSupplies, vault?.id]
+
+  return useQuery({
+    queryKey,
+    queryFn: async () => await vault.getTotalDelegateSupply(),
+    enabled: !!vault,
+    ...NO_REFETCH
+  })
+}

shared/utilities/utils/vaults.ts

@@ -346,3 +346,46 @@ export const getVaultUnderlyingTokenAddresses = async (
 
   return tokenAddresses
 }
+
+/**
+ * Returns each vault's total delegate supply (total supply - sponsored supply)
+ * @param publicClient a public Viem client for the chain that should be queried
+ * @param vaults vaults to query through
+ * @param twabController the address of the TWAB controller to query through
+ * @returns
+ */
+export const getVaultTotalDelegateSupplies = async (
+  publicClient: PublicClient,
+  vaults: VaultInfo[],
+  twabController: Address
+): Promise<{
+  [vaultId: string]: bigint
+}> => {
+  const vaultTotalDelegateSupplies: { [vaultId: string]: bigint } = {}
+  const chainId = await publicClient.getChainId()
+  const filteredVaults = !!chainId
+    ? vaults.filter((vault) => vault.chainId === chainId && vault.decimals !== undefined)
+    : []
+
+  if (filteredVaults.length > 0) {
+    const calls = filteredVaults.map(({ address }) => ({
+      functionName: 'totalSupplyDelegateBalance',
+      args: [address]
+    }))
+
+    const multicallResults = await getSimpleMulticallResults(
+      publicClient,
+      twabController,
+      twabControllerABI,
+      calls
+    )
+
+    filteredVaults.forEach((vaultInfo, i) => {
+      const result = multicallResults[i]
+      const vaultId = getVaultId(vaultInfo)
+      vaultTotalDelegateSupplies[vaultId] = result
+    })
+  }
+
+  return vaultTotalDelegateSupplies
+}