Merge pull request #323 from Gearbox-protocol/pool-rewards

feat: pool rewards

Author: essserrr

src/core/endpoint.ts

@@ -107,6 +107,10 @@ export class GearboxBackendApi {
     URLApi.getRelativeUrl("https://apy-server.fly.dev/api/rewards/gear-apy", {
       params: { chain_id: chainId },
     });
+  static apyServerAllPoolRewards = (chainId: number) =>
+    URLApi.getRelativeUrl("https://apy-server.fly.dev/api/rewards/pools/all", {
+      params: { chain_id: chainId },
+    });
 }
 
 interface Options {

src/gearboxRewards/extraAPY.ts

@@ -1,28 +1,35 @@
 import {
   CHAINS,
   NetworkType,
-  PartialRecord,
   PERCENTAGE_FACTOR,
-  SupportedToken,
-  TypedObjectUtils,
 } from "@gearbox-protocol/sdk-gov";
 import axios from "axios";
 import { Address } from "viem";
 
-import { poolByNetwork } from "../contracts/contractsRegister";
 import { Asset } from "../core/assets";
 import { GearboxBackendApi } from "../core/endpoint";
 import { PoolData } from "../core/pool";
 import { TokenData } from "../tokens/tokenData";
 import { toBN } from "../utils/formatter";
 import { BigIntMath } from "../utils/math";
 
+export interface PoolPointsInfo {
+  pool: Address;
+  token: Address;
+  symbol: string;
+
+  amount: bigint;
+  duration: string;
+  name: string;
+  estimation: "absolute" | "relative";
+}
+
 export interface GetPointsByPoolProps {
+  poolRewards: Record<Address, Record<Address, PoolPointsInfo>>;
+
   totalTokenBalances: Record<Address, Asset>;
   pools: Array<PoolData>;
-  currentTokenData: Record<SupportedToken, Address>;
   tokensList: Record<Address, TokenData>;
-  network: NetworkType;
 }
 
 interface WalletResult {
@@ -35,101 +42,26 @@ interface GetBalanceAtResponse {
 }
 
 export interface GetTotalTokensOnProtocolProps {
-  currentTokenData: Record<SupportedToken, Address>;
+  tokensToCheck: Array<Address>;
+
   tokensList: Record<Address, TokenData>;
   network: NetworkType;
-
-  extraTokens?: Array<SupportedToken>;
-}
-
-interface PoolPointsInfo {
-  amount: bigint;
-  symbol: SupportedToken;
-  duration: string;
-  name: string;
-  estimation: "absolute" | "relative";
 }
 
-const POOL_POINTS: Record<
-  NetworkType,
-  Record<Address, PartialRecord<SupportedToken, PoolPointsInfo>>
-> = {
-  Mainnet: {
-    [poolByNetwork.Mainnet.WETH_V3_TRADE]: {
-      rsETH: {
-        amount: 7500n * 10000n,
-        symbol: "rsETH",
-        duration: "hour",
-        name: "Kelp Mile",
-        estimation: "relative",
-      },
-    },
-    [poolByNetwork.Mainnet.WBTC_V3_TRADE]: {
-      LBTC: {
-        amount: 2000n * 10000n,
-        symbol: "LBTC",
-        duration: "day",
-        name: "Lombard LUX",
-        estimation: "absolute",
-      },
-      pumpBTC: {
-        amount: 172_800n * 10000n,
-        symbol: "pumpBTC",
-        duration: "day",
-        name: "Pump BTC",
-        estimation: "absolute",
-      },
-    },
-  },
-  Arbitrum: {},
-  Optimism: {},
-  Base: {},
-};
-
-const TOKENS = TypedObjectUtils.entries(POOL_POINTS).reduce<
-  Record<NetworkType, Array<SupportedToken>>
->((acc, [network, pools]) => {
-  const r = Object.values(pools).reduce<Array<SupportedToken>>(
-    (acc, tokens) => {
-      const l = Object.keys(tokens) as Array<SupportedToken>;
-      acc.push(...l);
-      return acc;
-    },
-    [],
-  );
-
-  acc[network] = r;
-
-  return acc;
-}, {} as Record<NetworkType, Array<SupportedToken>>);
-
-const CA_REWARDS: Record<NetworkType, Array<SupportedToken>> = {
-  Mainnet: [],
-  Arbitrum: [],
-  Optimism: ["ezETH"],
-  Base: [],
-};
-
 export class GearboxRewardsExtraApy {
   static async getTotalTokensOnProtocol({
-    currentTokenData,
+    tokensToCheck,
+
     tokensList,
     network,
-
-    extraTokens = [],
   }: GetTotalTokensOnProtocolProps) {
-    const poolTokens = TOKENS[network];
-    const caTokens = CA_REWARDS[network];
-
-    const list = [...new Set([...poolTokens, ...caTokens, ...extraTokens])];
+    const list = [...new Set(tokensToCheck)];
 
     const res = await Promise.allSettled(
-      list.map(s =>
-        this.getTokenTotal(currentTokenData[s], network, tokensList),
-      ),
+      list.map(t => this.getTokenTotal(t, network, tokensList)),
     );
 
-    return res.map((r, i): [SupportedToken, PromiseSettledResult<Asset>] => [
+    return res.map((r, i): [Address, PromiseSettledResult<Asset>] => [
       list[i],
       r,
     ]);
@@ -159,21 +91,19 @@ export class GearboxRewardsExtraApy {
   }
 
   static getPointsByPool({
+    poolRewards,
+
     totalTokenBalances,
     pools,
     tokensList,
-    currentTokenData,
-    network,
   }: GetPointsByPoolProps) {
     const r = pools.reduce<Record<Address, Array<Asset>>>((acc, p) => {
-      const poolPointsInfo = Object.values(
-        POOL_POINTS[network]?.[p.address] || [],
-      );
+      const pointsInfo = Object.values(poolRewards[p.address] || {});
 
-      const poolPointsList = poolPointsInfo.reduce<Array<Asset>>(
+      const poolPointsList = pointsInfo.reduce<Array<Asset>>(
         (acc, pointsInfo) => {
-          const tokenBalance =
-            totalTokenBalances[currentTokenData[pointsInfo.symbol] || ""];
+          const { address: tokenAddress } = tokensList[pointsInfo.token];
+          const tokenBalance = totalTokenBalances[tokenAddress || ""];
 
           const points = this.getPoolTokenPoints(
             tokenBalance,
@@ -227,11 +157,11 @@ export class GearboxRewardsExtraApy {
   }
 
   static getPoolPointsTip(
-    network: NetworkType,
+    poolRewards: Record<Address, Record<Address, PoolPointsInfo>>,
     pool: Address,
-    token: SupportedToken,
+    token: Address,
   ) {
-    const p = POOL_POINTS[network]?.[pool]?.[token];
+    const p = poolRewards[pool]?.[token];
     return p;
   }
 }