@gearbox-protocol/sdk 3.0.0-next.17 → 3.0.0-next.170

package/lib/core/{pool/data.js → pool.js}

@@ -2,12 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UserPoolData = exports.ChartsPoolData = exports.PoolData = void 0;
 const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
-const types_1 = require("../../types");
-const formatter_1 = require("../../utils/formatter");
+const types_1 = require("../types");
+const formatter_1 = require("../utils/formatter");
 class PoolData {
     address;
+    type;
     underlyingToken;
     dieselToken;
+    stakedDieselToken;
     isPaused;
     version;
     poolQuotaKeeper;
@@ -18,7 +20,8 @@ class PoolData {
     expectedLiquidity;
     expectedLiquidityLimit;
     availableLiquidity;
-    linearCumulativeIndex;
+    baseInterestIndex;
+    utilization;
     totalBorrowed;
     totalDebtLimit;
     creditManagerDebtParams;
@@ -26,28 +29,34 @@ class PoolData {
     zappers;
     totalAssets;
     totalSupply;
+    supplyAPY7D;
     depositAPY;
     borrowAPY;
     interestModel;
     dieselRate;
     dieselRateRay;
     withdrawFee;
-    cumulativeIndex_RAY;
+    lastBaseInterestUpdate;
     constructor(payload) {
         this.address = payload.addr.toLowerCase();
+        this.type = PoolData.getPoolType(payload.name || "");
         this.underlyingToken = payload.underlying.toLowerCase();
         this.dieselToken = payload.dieselToken.toLowerCase();
+        this.stakedDieselToken = (payload.stakedDieselToken || []).map(t => t.toLowerCase());
         this.isPaused = payload.isPaused;
         this.version = payload.version.toNumber();
         this.poolQuotaKeeper = payload.poolQuotaKeeper.toLowerCase();
         this.gauge = payload.gauge.toLowerCase();
         this.name = payload.name;
         this.symbol = payload.symbol;
-        this.expectedLiquidity = (0, sdk_gov_1.toBigInt)(payload.expectedLiquidity);
-        this.availableLiquidity = (0, sdk_gov_1.toBigInt)(payload.availableLiquidity);
+        const expected = (0, sdk_gov_1.toBigInt)(payload.expectedLiquidity);
+        const available = (0, sdk_gov_1.toBigInt)(payload.availableLiquidity);
+        this.expectedLiquidity = expected;
+        this.availableLiquidity = available;
         this.expectedLiquidityLimit =
             this.expectedLiquidity + this.availableLiquidity;
-        this.linearCumulativeIndex = (0, sdk_gov_1.toBigInt)(payload.linearCumulativeIndex);
+        this.baseInterestIndex = (0, sdk_gov_1.toBigInt)(payload.baseInterestIndex);
+        this.utilization = PoolData.calculateUtilization(expected, available);
         this.totalBorrowed = (0, sdk_gov_1.toBigInt)(payload.totalBorrowed);
         this.totalDebtLimit = (0, sdk_gov_1.toBigInt)(payload.totalDebtLimit);
         this.creditManagerDebtParams = Object.fromEntries(payload.creditManagerDebtParams.map(p => {
@@ -68,7 +77,7 @@ class PoolData {
                 token,
                 {
                     token,
-                    rate: q.rate,
+                    rate: Number((0, sdk_gov_1.toBigInt)(q.rate) * sdk_gov_1.PERCENTAGE_DECIMALS),
                     quotaIncreaseFee: q.quotaIncreaseFee,
                     totalQuoted: (0, sdk_gov_1.toBigInt)(q.totalQuoted),
                     limit: (0, sdk_gov_1.toBigInt)(q.limit),
@@ -76,21 +85,23 @@ class PoolData {
                 },
             ];
         }));
-        this.zappers = Object.fromEntries(payload.zappers.map(z => {
+        this.zappers = payload.zappers.reduce((acc, z) => {
             const tokenIn = z.tokenIn.toLowerCase();
-            return [
-                tokenIn,
-                {
-                    tokenIn,
-                    tokenOut: z.tokenOut.toLowerCase(),
-                    zapper: z.zapper.toLowerCase(),
+            const tokenOut = z.tokenOut.toLowerCase();
+            const old = acc[tokenIn] || {};
+            return {
+                ...acc,
+                [tokenIn]: {
+                    ...old,
+                    [tokenOut]: { tokenIn, tokenOut, zapper: z.zapper.toLowerCase() },
                 },
-            ];
-        }));
+            };
+        }, {});
         this.totalAssets = (0, sdk_gov_1.toBigInt)(payload.totalAssets);
         this.totalSupply = (0, sdk_gov_1.toBigInt)(payload.totalSupply);
         this.depositAPY = (0, formatter_1.rayToNumber)((0, sdk_gov_1.toBigInt)(payload.supplyRate) * sdk_gov_1.PERCENTAGE_DECIMALS);
         this.borrowAPY = (0, formatter_1.rayToNumber)((0, sdk_gov_1.toBigInt)(payload.baseInterestRate) * sdk_gov_1.PERCENTAGE_DECIMALS);
+        this.supplyAPY7D = payload.supplyAPY7D;
         this.interestModel = {
             interestModel: payload.lirm.interestModel.toLowerCase(),
             U_1: payload.lirm.U_1,
@@ -104,7 +115,7 @@ class PoolData {
         };
         this.dieselRate = (0, formatter_1.rayToNumber)(payload.dieselRate_RAY);
         this.dieselRateRay = (0, sdk_gov_1.toBigInt)(payload.dieselRate_RAY);
-        this.cumulativeIndex_RAY = (0, sdk_gov_1.toBigInt)(payload.cumulativeIndex_RAY);
+        this.lastBaseInterestUpdate = (0, sdk_gov_1.toBigInt)(payload.lastBaseInterestUpdate);
         this.withdrawFee =
             Number((0, sdk_gov_1.toBigInt)(payload.withdrawFee)) / Number(sdk_gov_1.PERCENTAGE_DECIMALS);
     }
@@ -118,14 +129,30 @@ class PoolData {
         const model = types_1.IInterestRateModel__factory.connect(this.interestModel.interestModel, provider);
         return model.calcBorrowRate(expectedLiquidity, availableLiquidity);
     }
+    static getPoolType(name) {
+        const [identity = ""] = name.split(" ") || [];
+        const lc = identity.toLowerCase();
+        if (lc === "farm")
+            return "farm";
+        if (lc === "trade")
+            return "trade";
+        return "universal";
+    }
+    static calculateUtilization(expected, available) {
+        return expected > 0
+            ? Number(((expected - available) * sdk_gov_1.PERCENTAGE_FACTOR) / expected) /
+                Number(sdk_gov_1.PERCENTAGE_DECIMALS)
+            : 0;
+    }
 }
 exports.PoolData = PoolData;
 class ChartsPoolData {
-    id;
     address;
     underlyingToken;
     dieselToken;
-    isWETH;
+    type;
+    version;
+    name;
     addLiqCount;
     addedLiquidity;
     removeLiqCount;
@@ -172,19 +199,14 @@ class ChartsPoolData {
     uniqueLPs;
     uniqueLPsChange;
     constructor(payload) {
-        this.id = (payload.addr || "").toLowerCase();
         this.address = (payload.addr || "").toLowerCase();
         this.underlyingToken = (payload.underlyingToken || "").toLowerCase();
         this.dieselToken = (payload.dieselToken || "").toLowerCase();
-        this.isWETH = payload.isWETH || false;
+        this.type = PoolData.getPoolType(payload.name || "");
+        this.version = payload.version || 1;
+        this.name = payload.name || "";
         this.earned7D = payload.earned7D || 0;
         this.earned7DInUSD = payload.earned7DInUSD || 0;
-        const expected = (0, sdk_gov_1.toBigInt)(payload.expectedLiquidity || 0);
-        this.utilization =
-            expected > 0
-                ? Number(((0, sdk_gov_1.toBigInt)(payload.totalBorrowed || 0) * sdk_gov_1.PERCENTAGE_FACTOR) /
-                    expected) / Number(sdk_gov_1.PERCENTAGE_DECIMALS)
-                : 0;
         this.dieselRate = (0, formatter_1.rayToNumber)(payload.dieselRate_RAY || 0);
         this.dieselRateRay = (0, sdk_gov_1.toBigInt)(payload.dieselRate_RAY || 0);
         this.depositAPY =
@@ -194,11 +216,14 @@ class ChartsPoolData {
             (0, formatter_1.rayToNumber)(payload.borrowAPY_RAY || 0) * Number(sdk_gov_1.PERCENTAGE_DECIMALS);
         this.borrowAPYRay = (0, sdk_gov_1.toBigInt)(payload.borrowAPY_RAY || 0);
         this.lmAPY = (payload.lmAPY || 0) / Number(sdk_gov_1.PERCENTAGE_DECIMALS);
-        this.availableLiquidity = (0, sdk_gov_1.toBigInt)(payload.availableLiquidity || 0);
+        const expected = (0, sdk_gov_1.toBigInt)(payload.expectedLiquidity || 0);
+        const available = (0, sdk_gov_1.toBigInt)(payload.availableLiquidity || 0);
+        this.availableLiquidity = available;
         this.oldAvailableLiquidity = (0, sdk_gov_1.toBigInt)(payload.availableLiquidityOld || 0);
         this.availableLiquidityChange =
             (payload.availableLiquidity10kBasis || 0) * Number(sdk_gov_1.PERCENTAGE_DECIMALS);
         this.availableLiquidityInUSD = payload.availableLiquidityInUSD || 0;
+        this.utilization = PoolData.calculateUtilization(expected, available);
         this.caLockedValue = payload.caLockedValue || 0;
         this.oldCALockedValue = payload.caLockedValueOld || 0;
         this.caLockedValueChange =

package/lib/core/rewardClaimer.d.ts

@@ -1,11 +1,13 @@
-import { NetworkType, SupportedContract, SupportedToken } from "@gearbox-protocol/sdk-gov";
+import { NetworkType, PartialRecord, Protocols, SupportedContract, SupportedToken } from "@gearbox-protocol/sdk-gov";
 import { providers } from "ethers";
 import { MultiCall } from "../pathfinder/core";
 import { CreditAccountData } from "./creditAccount";
 import { CreditManagerData } from "./creditManager";
 export interface Rewards {
     contract: SupportedContract;
-    rewards: Partial<Record<SupportedToken, bigint>>;
+    totalSupply: bigint;
+    protocol: Protocols.Aura | Protocols.Convex;
+    rewards: PartialRecord<SupportedToken, bigint>;
     calls: Array<MultiCall>;
 }
 export interface AdapterWithType {

package/lib/core/rewardConvex.d.ts

@@ -1,24 +1,41 @@
-import { MCall, NetworkType, SupportedContract, SupportedToken } from "@gearbox-protocol/sdk-gov";
+import { MCall, NetworkType, Protocols, SupportedToken } from "@gearbox-protocol/sdk-gov";
 import { BigNumber, providers } from "ethers";
+import { Interface } from "ethers/lib/utils";
 import { IBaseRewardPoolInterface } from "../types/IBaseRewardPool";
+import { IConvexTokenInterface } from "../types/IConvexToken";
 import { CreditAccountData } from "./creditAccount";
 import { CreditManagerData } from "./creditManager";
 import { AdapterWithType, Rewards } from "./rewardClaimer";
+type DistributionList = Array<Array<RewardDistribution>>;
+type CallsList = Array<Array<MCall<IConvexTokenInterface> | MCall<IBaseRewardPoolInterface> | MCall<Interface>>>;
 export interface RewardDistribution {
+    contract: Rewards["contract"];
+    protocol: Rewards["protocol"];
+    token: SupportedToken;
     adapter: string;
     contractAddress: string;
-    contract: SupportedContract;
-    token: SupportedToken;
 }
-interface MCallPreparation {
-    calls: Array<MCall<IBaseRewardPoolInterface>>;
-    distribution: Array<RewardDistribution>;
+interface ParseProps {
+    convexResponse: Array<BigNumber>;
+    convexDistribution: DistributionList;
+    convexTotalSupply: bigint;
+    auraResponse: Array<BigNumber>;
+    auraDistribution: DistributionList;
+    auraTotalSupply: bigint;
 }
 export declare class RewardConvex {
     static poolInterface: IBaseRewardPoolInterface;
     static findRewards(ca: CreditAccountData, cm: CreditManagerData, network: NetworkType, provider: providers.Provider): Promise<Array<Rewards>>;
-    static findAdapters(cm: CreditManagerData): Array<AdapterWithType>;
-    static prepareMultiCalls(creditAccount: string, cm: CreditManagerData, network: NetworkType): MCallPreparation;
-    static parseResults(rewards: Array<BigNumber>, distribution: Array<RewardDistribution>): Array<Rewards>;
+    static findAdapters(cm: CreditManagerData): AdapterWithType[];
+    static prepareMultiCalls(creditAccount: string, cm: CreditManagerData, network: NetworkType): {
+        convexDistribution: DistributionList;
+        auraDistribution: DistributionList;
+        convexCalls: CallsList;
+        auraCalls: CallsList;
+    } | undefined;
+    static parseResults({ convexDistribution, convexResponse, convexTotalSupply, auraDistribution, auraResponse, auraTotalSupply, }: ParseProps): Array<Rewards>;
+    static getRewardObject(baseReward: bigint, baseDistribution: RewardDistribution, boostedRewardToken: SupportedToken, extraDistribution: Array<RewardDistribution>, rewardsResp: Array<BigNumber>, totalSupply: bigint, callData: string, multiplier: bigint): Rewards | undefined;
+    static getBaseRewardToken(protocol: Protocols): SupportedToken | undefined;
+    static getBBoostedRewardToken(protocol: Protocols): SupportedToken | undefined;
 }
 export {};

package/lib/core/rewardConvex.js

@@ -3,98 +3,234 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RewardConvex = void 0;
 const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
 const apy_1 = require("../apy");
+const auraAbi_1 = require("../apy/auraAbi");
+const auraAPY_1 = require("../apy/auraAPY");
 const types_1 = require("../types");
+// convex[totalSupply, ...tokens] aura[totalSupply, multiplier, ...tokens]
 class RewardConvex {
     static poolInterface = types_1.IBaseRewardPool__factory.createInterface();
     static async findRewards(ca, cm, network, provider) {
-        const { calls, distribution } = RewardConvex.prepareMultiCalls(ca.addr, cm, network);
-        const mcalls = calls;
-        mcalls.push({
-            address: sdk_gov_1.tokenDataByNetwork[network].CVX,
-            interface: types_1.IConvexToken__factory.createInterface(),
-            method: "totalSupply()",
-        });
-        const rewards = await (0, sdk_gov_1.multicall)(mcalls, provider);
-        const totalSupply = rewards.pop();
-        const results = RewardConvex.parseResults(rewards, distribution);
-        results.forEach(r => {
-            r.rewards.CVX = (0, apy_1.getCVXMintAmount)(r.rewards.CRV || 0n, (0, sdk_gov_1.toBigInt)(totalSupply));
+        const prepared = RewardConvex.prepareMultiCalls(ca.addr, cm, network);
+        if (!prepared)
+            return [];
+        const { auraCalls, auraDistribution, convexCalls, convexDistribution } = prepared;
+        const auraTotal = auraCalls.flat(1);
+        const convexTotal = convexCalls.flat(1);
+        const allCalls = [...auraTotal, ...convexTotal];
+        if (allCalls.length === 0)
+            return [];
+        const response = await (0, sdk_gov_1.multicall)(allCalls, provider);
+        const auraEnd = auraTotal.length;
+        const [auraTotalSupply, ...auraResponse] = response.slice(0, auraEnd);
+        const convexEnd = auraEnd + convexTotal.length;
+        const [convexTotalSupply, ...convexResponse] = response.slice(auraEnd, convexEnd);
+        const results = RewardConvex.parseResults({
+            auraDistribution,
+            auraResponse,
+            auraTotalSupply: (0, sdk_gov_1.toBigInt)(auraTotalSupply),
+            convexDistribution,
+            convexResponse,
+            convexTotalSupply: (0, sdk_gov_1.toBigInt)(convexTotalSupply),
         });
         return results;
     }
     static findAdapters(cm) {
-        const convexPools = Object.entries(sdk_gov_1.contractParams)
-            .filter(([_, params]) => params.type === sdk_gov_1.AdapterInterface.CONVEX_V1_BASE_REWARD_POOL)
-            .map(([contract]) => contract);
+        const convexPools = sdk_gov_1.TypedObjectUtils.fromEntries(sdk_gov_1.TypedObjectUtils.entries(sdk_gov_1.contractParams).filter(([, params]) => params.type === sdk_gov_1.AdapterInterface.CONVEX_V1_BASE_REWARD_POOL));
         return Object.entries(cm.adapters)
+            .filter(([contract]) => !!convexPools[sdk_gov_1.contractsByAddress[contract.toLowerCase()]])
             .map(([contract, adapter]) => ({
             adapter,
             contractAddress: contract,
             contract: sdk_gov_1.contractsByAddress[contract.toLowerCase()],
-        }))
-            .filter(a => convexPools.includes(a.contract));
+        }));
     }
     static prepareMultiCalls(creditAccount, cm, network) {
-        const calls = [];
-        const distribution = [];
+        const tokens = sdk_gov_1.tokenDataByNetwork[network];
+        const contracts = sdk_gov_1.contractsByNetwork[network];
         const adapters = this.findAdapters(cm);
-        for (let a of adapters) {
-            calls.push({
+        if (adapters.length === 0) {
+            return undefined;
+        }
+        const res = adapters.reduce((acc, a) => {
+            const currentContract = sdk_gov_1.contractParams[a.contract];
+            const baseRewardToken = this.getBaseRewardToken(currentContract.protocol);
+            if (!baseRewardToken) {
+                throw new Error(`Unknown rewards protocol: ${currentContract.protocol}`);
+            }
+            const currentCalls = [
+                ...(currentContract.protocol === sdk_gov_1.Protocols.Aura
+                    ? [
+                        {
+                            address: contracts.AURA_BOOSTER,
+                            interface: auraAbi_1.AURA_BOOSTER_INTERFACE,
+                            method: "getRewardMultipliers(address)",
+                            params: [tokens[currentContract.stakedToken]],
+                        },
+                    ]
+                    : []),
+            ];
+            const currentDistribution = [];
+            currentCalls.push({
                 address: a.contractAddress,
                 interface: RewardConvex.poolInterface,
                 method: "earned(address)",
                 params: [creditAccount],
             });
-            distribution.push({
+            currentDistribution.push({
+                protocol: currentContract.protocol,
+                contract: a.contract,
+                token: baseRewardToken,
                 contractAddress: a.contractAddress,
                 adapter: a.adapter,
-                contract: a.contract,
-                token: "CRV",
             });
-            const params = sdk_gov_1.contractParams[a.contract];
-            for (let er of params.extraRewards) {
-                calls.push({
-                    address: er.poolAddress[network],
+            currentContract.extraRewards.forEach(extra => {
+                currentCalls.push({
+                    address: extra.poolAddress[network],
                     interface: RewardConvex.poolInterface,
                     method: "earned(address)",
                     params: [creditAccount],
                 });
-                distribution.push({
+                currentDistribution.push({
+                    protocol: currentContract.protocol,
+                    contract: a.contract,
+                    token: extra.rewardToken,
                     contractAddress: a.contractAddress,
                     adapter: a.adapter,
-                    contract: a.contract,
-                    token: er.rewardToken,
                 });
+            });
+            if (currentContract.protocol === sdk_gov_1.Protocols.Aura) {
+                acc.auraCalls.push(currentCalls);
+                acc.auraDistribution.push(currentDistribution);
             }
-        }
-        return {
-            calls,
-            distribution,
-        };
+            else if (currentContract.protocol === sdk_gov_1.Protocols.Convex) {
+                acc.convexCalls.push(currentCalls);
+                acc.convexDistribution.push(currentDistribution);
+            }
+            return acc;
+        }, {
+            convexDistribution: [],
+            auraDistribution: [],
+            convexCalls: [
+                [
+                    {
+                        address: tokens.CVX,
+                        interface: types_1.IConvexToken__factory.createInterface(),
+                        method: "totalSupply()",
+                    },
+                ],
+            ],
+            auraCalls: [
+                [
+                    {
+                        address: tokens.AURA,
+                        interface: types_1.IConvexToken__factory.createInterface(),
+                        method: "totalSupply()",
+                    },
+                ],
+            ],
+        });
+        return res;
     }
-    static parseResults(rewards, distribution) {
-        const result = {};
+    static parseResults({ convexDistribution, convexResponse, convexTotalSupply, auraDistribution, auraResponse, auraTotalSupply, }) {
         const callData = RewardConvex.poolInterface.encodeFunctionData("getReward()");
-        for (let i = 0; i < rewards.length; i++) {
-            const { contract, adapter, token } = distribution[i];
-            const reward = rewards[i];
-            if (!reward.isZero()) {
-                if (!result[contract]) {
-                    result[contract] = {
-                        contract,
-                        rewards: {},
-                        calls: [
-                            {
-                                target: adapter,
-                                callData,
-                            },
-                        ],
-                    };
-                }
-                result[contract].rewards[token] = BigInt(reward.toString());
+        const rewardsRecord = {};
+        let start = 0;
+        convexDistribution.forEach(list => {
+            // rewards[]
+            const end = start + list.length;
+            const [baseRewardResp, ...rewardsResp] = convexResponse.slice(start, end);
+            start = end;
+            const [baseDistribution, ...extraDistribution] = list;
+            const boostedRewardToken = this.getBBoostedRewardToken(baseDistribution.protocol);
+            if (rewardsResp.length !== extraDistribution.length ||
+                baseRewardResp === undefined) {
+                throw new Error(`Rewards response length mismatch: expected: ${extraDistribution.length}, got: ${rewardsResp.length}`);
             }
+            if (!boostedRewardToken) {
+                throw new Error(`Unknown rewards protocol: ${baseDistribution.protocol}`);
+            }
+            // create base
+            const rewardObject = this.getRewardObject((0, sdk_gov_1.toBigInt)(baseRewardResp || 0n), baseDistribution, boostedRewardToken, extraDistribution, rewardsResp, convexTotalSupply, callData, 0n);
+            if (rewardObject)
+                rewardsRecord[baseDistribution.contract] = rewardObject;
+        });
+        start = 0;
+        auraDistribution.forEach(list => {
+            // multiplier + rewards[]
+            const end = start + list.length + 1;
+            const [mp, baseRewardResp, ...rewardsResp] = auraResponse.slice(start, end);
+            start = end;
+            const multiplier = (0, sdk_gov_1.toBigInt)(mp);
+            const [baseDistribution, ...extraDistribution] = list;
+            const boostedRewardToken = this.getBBoostedRewardToken(baseDistribution.protocol);
+            if (rewardsResp.length !== extraDistribution.length ||
+                mp === undefined ||
+                baseRewardResp === undefined) {
+                throw new Error(`Rewards response length mismatch: expected: ${extraDistribution.length}, got: ${rewardsResp.length}`);
+            }
+            if (!boostedRewardToken) {
+                throw new Error(`Unknown rewards protocol: ${baseDistribution.protocol}`);
+            }
+            // create base
+            const rewardObject = this.getRewardObject((0, sdk_gov_1.toBigInt)(baseRewardResp || 0n), baseDistribution, boostedRewardToken, extraDistribution, rewardsResp, auraTotalSupply, callData, multiplier);
+            if (rewardObject)
+                rewardsRecord[baseDistribution.contract] = rewardObject;
+        });
+        const result = Object.values(rewardsRecord);
+        return result;
+    }
+    static getRewardObject(baseReward, baseDistribution, boostedRewardToken, extraDistribution, rewardsResp, totalSupply, callData, multiplier) {
+        // create base
+        const base = {
+            contract: baseDistribution.contract,
+            totalSupply: totalSupply,
+            protocol: baseDistribution.protocol,
+            rewards: {
+                [baseDistribution.token]: baseReward,
+            },
+            calls: [
+                {
+                    target: baseDistribution.adapter,
+                    callData,
+                },
+            ],
+        };
+        // add boosted
+        const boostedReward = baseDistribution.protocol === sdk_gov_1.Protocols.Aura
+            ? (0, auraAPY_1.getAURAMintAmount)(baseReward, totalSupply, multiplier)
+            : (0, apy_1.getCVXMintAmount)(baseReward, totalSupply);
+        base.rewards = {
+            ...base.rewards,
+            [boostedRewardToken]: boostedReward,
+        };
+        // extra
+        extraDistribution.forEach((distribution, j) => {
+            const token = distribution.token;
+            const prevReward = base.rewards[token] || 0n;
+            const reward = (0, sdk_gov_1.toBigInt)(rewardsResp[j] || 0n);
+            base.rewards = {
+                ...base.rewards,
+                [token]: prevReward + reward,
+            };
+        });
+        if (Object.values(base.rewards).some(r => r > 0)) {
+            return base;
         }
-        return Object.values(result);
+        return undefined;
+    }
+    static getBaseRewardToken(protocol) {
+        return protocol === sdk_gov_1.Protocols.Aura
+            ? "BAL"
+            : protocol === sdk_gov_1.Protocols.Convex
+                ? "CRV"
+                : undefined;
+    }
+    static getBBoostedRewardToken(protocol) {
+        return protocol === sdk_gov_1.Protocols.Aura
+            ? "AURA"
+            : protocol === sdk_gov_1.Protocols.Convex
+                ? "CVX"
+                : undefined;
     }
 }
 exports.RewardConvex = RewardConvex;