Implement pot farm balance

src/api/farms.ts

@@ -3,8 +3,14 @@ import { u32 } from "@polkadot/types-codec"
 import { AccountId32 } from "@polkadot/types/interfaces/runtime"
 import { useQueries, useQuery } from "@tanstack/react-query"
 import { useApiPromise } from "utils/api"
+import { getAccountResolver } from "utils/farms/claiming/accountResolver"
 import { isNotNil, useQueryReduce } from "utils/helpers"
 import { QUERY_KEYS } from "utils/queryKeys"
+import { PROVIDERS, useProviderRpcUrlStore } from "./provider"
+import { u8aToHex } from "@polkadot/util"
+import { decodeAddress } from "@polkadot/util-crypto"
+import { BN_0, TREASURY_WALLET } from "utils/constants"
+import request, { gql } from "graphql-request"
 
 export const useYieldFarms = (ids: FarmIds[]) => {
   const { api } = useApiPromise()
@@ -55,13 +61,23 @@ export const useInactiveYieldFarms = (poolIds: (AccountId32 | string)[]) => {
 }
 
 export const useFarms = (poolIds: Array<AccountId32 | string>) => {
+  const { api } = useApiPromise()
   const activeYieldFarms = useActiveYieldFarms(poolIds)
 
   const data = activeYieldFarms.reduce(
     (acc, farm) => (farm.data ? [...acc, ...farm.data] : acc),
     [] as FarmIds[],
   )
 
+  const accountResolver = getAccountResolver(api.registry)
+  const globalFarmPotAddresses = data?.map((farm) => {
+    const potAddresss = accountResolver(farm.globalFarmId).toString()
+    return {
+      globalFarmId: farm.globalFarmId.toString(),
+      potAddresss,
+    }
+  })
+
   const globalFarms = useGlobalFarms(data.map((id) => id.globalFarmId))
   const yieldFarms = useYieldFarms(data)
 
@@ -74,8 +90,11 @@ export const useFarms = (poolIds: Array<AccountId32 | string>) => {
             af.globalFarmId.eq(gf.id),
           )
           const yieldFarm = yieldFarms?.find((yf) => af.yieldFarmId.eq(yf.id))
+          const globalFarmPotAddress = globalFarmPotAddresses.find(
+            (farm) => farm.globalFarmId === globalFarm?.id.toString(),
+          )?.potAddresss
           if (!globalFarm || !yieldFarm) return undefined
-          return { globalFarm, yieldFarm }
+          return { globalFarm, yieldFarm, globalFarmPotAddress }
         }) ?? []
       return farms.filter(isNotNil)
     },
@@ -225,3 +244,61 @@ export interface FarmIds {
   globalFarmId: u32
   yieldFarmId: u32
 }
+
+export const useFarmPotTransfers = (potAddresses: string[]) => {
+  const preference = useProviderRpcUrlStore()
+  const rpcUrl = preference.rpcUrl ?? import.meta.env.VITE_PROVIDER_URL
+  const selectedProvider = PROVIDERS.find(
+    (provider) => new URL(provider.url).hostname === new URL(rpcUrl).hostname,
+  )
+
+  const indexerUrl =
+    selectedProvider?.indexerUrl ?? import.meta.env.VITE_INDEXER_URL
+
+  return useQueries({
+    queries: potAddresses.map((potAddress) => ({
+      queryKey: QUERY_KEYS.potTransfers(potAddress),
+      queryFn: async () => {
+        const transfers = await getTransfers(indexerUrl, potAddress)
+        const sum = transfers.events.reduce((acc, transfer) => {
+          if (
+            transfer.args.to.slice(0, 26) !== transfer.args.from.slice(0, 26)
+          ) {
+            return acc.plus(transfer.args.amount)
+          }
+
+          return acc
+        }, BN_0)
+        return { amount: sum.toString(), potAddress }
+      },
+      enabled: !!potAddress,
+    })),
+  })
+}
+
+const getTransfers = async (indexerUrl: string, address: string) => {
+  const potAddress = u8aToHex(decodeAddress(address))
+  const treasuryAddress = u8aToHex(decodeAddress(TREASURY_WALLET))
+
+  return {
+    ...(await request<{
+      events: Array<{ args: { to: string; from: string; amount: string } }>
+    }>(
+      indexerUrl,
+      gql`
+        query FarmTransfers($potAddress: String!) {
+          events(
+            where: {
+              name_in: ["Balances.Transfer", "Tokens.Transfer"]
+              args_jsonContains: { to: $potAddress }
+            }
+            orderBy: block_height_ASC
+          ) {
+            args
+          }
+        }
+      `,
+      { potAddress, treasuryAddress },
+    )),
+  }
+}

src/sections/pools/farm/detail/PoolFarmDetail.tsx

@@ -91,7 +91,7 @@ export const PoolFarmDetail = (props: {
         <SFarmRow>
           <FillBar
             percentage={props.farm.distributedRewards
-              .div(props.farm.maxRewards)
+              .div(props.farm.potMaxBalance ?? props.farm.maxRewards)
               .times(100)
               .toNumber()}
           />
@@ -104,7 +104,10 @@ export const PoolFarmDetail = (props: {
                   props.farm.distributedRewards,
                   12,
                 ),
-                max: getFloatingPointAmount(props.farm.maxRewards, 12),
+                max: getFloatingPointAmount(
+                  props.farm.potMaxBalance ?? props.farm.maxRewards,
+                  12,
+                ),
               }}
             >
               <Text as="span" fs={14} color="neutralGray100" />

src/utils/constants.ts

@@ -25,3 +25,6 @@ export const ORMLVEST = "ormlvest"
 
 // asset type
 export const ASSET_TYPE_TOKEN = "Token"
+
+export const TREASURY_WALLET =
+  "bXj4uMHTyQyvNCLHKBv6ztwkPSx8tgsrxuFtAFfWDYntXtohw"

src/utils/farms/apr.ts

@@ -2,11 +2,11 @@ import * as liquidityMining from "@galacticcouncil/math-liquidity-mining"
 import { AccountId32 } from "@polkadot/types/interfaces/runtime"
 import { PalletLiquidityMiningLoyaltyCurve } from "@polkadot/types/lookup"
 import { useBestNumber } from "api/chain"
-import { useFarms } from "api/farms"
+import { useFarmPotTransfers, useFarms } from "api/farms"
 import BigNumber from "bignumber.js"
 import { secondsInYear } from "date-fns"
 import { BLOCK_TIME, BN_0, BN_1, BN_QUINTILL } from "utils/constants"
-import { useQueryReduce } from "utils/helpers"
+import { isNotNil, useQueryReduce } from "utils/helpers"
 
 export type AprFarm = NonNullable<
   Exclude<ReturnType<typeof useAPR>["data"], undefined>[number]
@@ -16,11 +16,17 @@ export const useAPR = (poolId: AccountId32 | string) => {
   const bestNumber = useBestNumber()
   const poolFarms = useFarms([poolId])
 
+  const potAddresses =
+    poolFarms.data?.map((farm) => farm.globalFarmPotAddress).filter(isNotNil) ??
+    []
+
+  const potTransfers = useFarmPotTransfers(potAddresses)
+
   return useQueryReduce(
     [bestNumber, poolFarms] as const,
     (bestNumber, poolFarms) => {
       const data = poolFarms.map((farm) => {
-        const { globalFarm, yieldFarm } = farm
+        const { globalFarm, yieldFarm, globalFarmPotAddress } = farm
 
         const loyaltyFactor = yieldFarm.loyaltyCurve.isNone
           ? BN_1
@@ -101,11 +107,19 @@ export const useAPR = (poolId: AccountId32 | string) => {
           .times(yieldPerPeriod)
           .div(maxRewardPerPeriod)
 
+        const potMaxBalance = BigNumber(
+          potTransfers.find(
+            (potTransfer) =>
+              potTransfer.data?.potAddress === globalFarmPotAddress,
+          )?.data?.amount ?? 0,
+        )
+
         return {
           minApr,
           apr,
           distributedRewards,
           maxRewards,
+          potMaxBalance,
           fullness,
           estimatedEndBlock: estimatedEndBlock,
           assetId: globalFarm.rewardCurrency,

src/utils/queryKeys.ts

@@ -174,4 +174,5 @@ export const QUERY_KEYS = {
     walletAddress,
   ],
   polkadotAccounts: ["polkadotAccounts"],
+  potTransfers: (address: string) => ["potTransfers", address],
 } as const