@gearbox-protocol/sdk 2.1.37 → 3.0.0-draft.1

package/lib/gearboxRewards/api.d.ts

@@ -0,0 +1,104 @@
+import { NetworkType, SupportedToken } from "@gearbox-protocol/sdk-gov";
+import { Address, PublicClient, WalletClient } from "viem";
+import { PoolData } from "../core/pool";
+import { TokenData } from "../tokens/tokenData";
+import { ExtraRewardApy } from "./apy";
+export interface GearboxExtraMerkleLmReward {
+    pool: Address;
+    poolToken: Address;
+    rewardTokenSymbol: string;
+    rewardTokenDecimals: number;
+    rewardToken: Address;
+    amount: bigint;
+    type: "extraMerkle";
+}
+export interface GearboxStakedV3LmReward {
+    pool: Address;
+    poolToken: Address;
+    rewardTokenSymbol: string;
+    rewardTokenDecimals: number;
+    rewardToken: Address;
+    amount: bigint;
+    type: "stakedV3";
+}
+export interface GearboxMerkleV2LmReward {
+    pool?: undefined;
+    poolToken?: undefined;
+    rewardTokenSymbol: string;
+    rewardTokenDecimals: number;
+    rewardToken: Address;
+    amount: bigint;
+    type: "merkleV2";
+}
+export type GearboxLmReward = GearboxStakedV3LmReward | GearboxMerkleV2LmReward | GearboxExtraMerkleLmReward;
+export interface MerkleDistributorInfo {
+    merkleRoot: string;
+    tokenTotal: string;
+    claims: Record<string, {
+        index: number;
+        amount: string;
+        proof: Array<Address>;
+    }>;
+}
+export interface FarmInfo {
+    pool: Address;
+    finished: bigint;
+    duration: bigint;
+    reward: bigint;
+    balance: bigint;
+    symbol: SupportedToken;
+}
+type ReportHandler = (e: unknown, description?: string) => void;
+export interface GetLmRewardsInfoProps {
+    pools: Record<Address, PoolData>;
+    tokensList: Record<Address, TokenData>;
+    provider: PublicClient;
+}
+export interface GetExtraRewardsProps {
+    chainId: number;
+    tokensList: Record<Address, TokenData>;
+}
+export interface GetLmRewardsProps {
+    pools: Record<Address, PoolData>;
+    baseRewardPoolsInfo: Record<string, FarmInfo>;
+    currentTokenData: Record<SupportedToken, Address>;
+    tokensList: Record<Address, TokenData>;
+    account: Address;
+    provider: PublicClient;
+    airdropDistributorAddress: Address | undefined;
+    network: NetworkType;
+    reportError?: ReportHandler;
+}
+export interface ClaimLmRewardsV2Props {
+    signer: WalletClient;
+    account: Address;
+    provider: PublicClient;
+    airdropDistributorAddress: Address | undefined;
+    network: NetworkType;
+}
+export interface ClaimLmRewardsV3Props {
+    reward: GearboxStakedV3LmReward;
+    account: Address;
+    signer: WalletClient;
+}
+export declare class GearboxRewardsApi {
+    static getExtraRewards({ chainId, tokensList }: GetExtraRewardsProps): Promise<Record<`0x${string}`, ExtraRewardApy[]>>;
+    static getLmRewardsInfo({ pools, provider, tokensList, }: GetLmRewardsInfoProps): Promise<{
+        rewardPoolsInfo: Record<string, FarmInfo[]>;
+        baseRewardPoolsInfo: Record<string, FarmInfo>;
+        rewardPoolsSupply: Record<string, bigint>;
+    }>;
+    static getLmRewardsV2({ provider, account, currentTokenData, network, airdropDistributorAddress, }: GetLmRewardsProps): Promise<{
+        rewards: GearboxLmReward[];
+    }>;
+    static getLmRewardsV3({ pools, baseRewardPoolsInfo, currentTokenData, tokensList, provider, account, network, reportError, }: GetLmRewardsProps): Promise<{
+        rewards: (GearboxLmReward | GearboxLmReward[])[];
+    }>;
+    private static extractFulfilled;
+    static claimLmRewardsV2({ signer, account, provider, network, airdropDistributorAddress, }: ClaimLmRewardsV2Props): Promise<`0x${string}`>;
+    static claimLmRewardsV3({ reward, signer, account, }: ClaimLmRewardsV3Props): Promise<`0x${string}`>;
+    private static getMerkle;
+    private static getClaimed;
+    private static getAmountOnContract;
+}
+export {};

package/lib/gearboxRewards/api.js

@@ -0,0 +1,359 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GearboxRewardsApi = void 0;
+const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
+const axios_1 = __importDefault(require("axios"));
+const viem_1 = require("viem");
+const endpoint_1 = require("../core/endpoint");
+const types_1 = require("../types");
+const math_1 = require("../utils/math");
+const merklAPI_1 = require("./merklAPI");
+const BROKEN_CAMPAIGNS = {
+    "11136065905617273958": true,
+};
+class GearboxRewardsApi {
+    static async getExtraRewards({ chainId, tokensList }) {
+        const res = await axios_1.default.get(merklAPI_1.MerkleXYZApi.getGearboxCampaignsUrl());
+        const currentActiveCampaigns = res.data.filter(c => c.status === "LIVE" && c.chainId === chainId && !BROKEN_CAMPAIGNS[c.id]);
+        const aprIdsList = currentActiveCampaigns
+            .map(c => 
+        // apr token for campaigns with a single reward is obvious
+        c.aprRecord.breakdowns.length > 1
+            ? c.aprRecord.breakdowns.map(b => {
+                return {
+                    campaignId: c.id,
+                    aprId: b.identifier,
+                };
+            })
+            : [])
+            .flat(1);
+        const aprIdsResponse = await Promise.allSettled(aprIdsList.map(id => axios_1.default.get(merklAPI_1.MerkleXYZApi.getGearboxRewardCampaignUrl(id.aprId))));
+        const aprCampaignByAPRId = aprIdsResponse.reduce((acc, r, i) => {
+            const id = aprIdsList[i].aprId;
+            acc[id] = r.status === "fulfilled" ? r.value.data : undefined;
+            return acc;
+        }, {});
+        const r = currentActiveCampaigns.reduce((acc, campaign) => {
+            const rewardSource = (campaign.tokens[0]?.address || campaign.identifier).toLowerCase();
+            const allRewards = campaign.aprRecord.breakdowns
+                .map((r, i) => {
+                const apy = r.value;
+                const { rewardToken } = aprCampaignByAPRId[r.identifier]?.[0] || {};
+                const tokenRewardsRecord = campaign.rewardsRecord.breakdowns[i]?.token;
+                const { address = tokenRewardsRecord?.address || "" } = rewardToken || {};
+                const tokenLc = address.toLowerCase();
+                const { symbol = rewardToken?.symbol || tokenRewardsRecord?.symbol || "", } = tokensList[tokenLc] || {};
+                const apyObject = {
+                    token: rewardSource,
+                    balance: null,
+                    apy: apy,
+                    rewardToken: tokenLc,
+                    rewardTokenSymbol: symbol,
+                };
+                return apyObject;
+            })
+                .filter(r => r.apy > 0);
+            acc[rewardSource] = [...(acc[rewardSource] || []), ...allRewards];
+            return acc;
+        }, {});
+        return r;
+    }
+    static async getLmRewardsInfo({ pools, provider, tokensList, }) {
+        const poolByStakedDiesel = Object.values(pools).reduce((acc, p) => {
+            p.stakedDieselToken.forEach(t => {
+                if (t)
+                    acc[t] = p.address;
+            });
+            p.stakedDieselToken_old.forEach(t => {
+                if (t)
+                    acc[t] = p.address;
+            });
+            return acc;
+        }, {});
+        const poolByDiesel = Object.values(pools).reduce((acc, p) => {
+            acc[p.dieselToken] = p.address;
+            return acc;
+        }, {});
+        const poolByItsToken = { ...poolByStakedDiesel, ...poolByDiesel };
+        const poolStakedTokens = sdk_gov_1.TypedObjectUtils.keys(poolByStakedDiesel);
+        const allPoolTokens = sdk_gov_1.TypedObjectUtils.keys(poolByItsToken);
+        const farmInfoCalls = poolStakedTokens.map(address => ({
+            address,
+            abi: types_1.iFarmingPoolAbi,
+            functionName: "farmInfo",
+            args: [],
+        }));
+        const farmSupplyCalls = allPoolTokens.map(address => ({
+            address,
+            abi: types_1.iFarmingPoolAbi,
+            functionName: "totalSupply",
+            args: [],
+        }));
+        const rewardTokenCalls = poolStakedTokens.map(address => ({
+            address,
+            abi: POOL_REWARDS_ABI,
+            functionName: "rewardsToken",
+            args: [],
+        }));
+        const mc = await provider.multicall({
+            allowFailure: false,
+            multicallAddress: sdk_gov_1.MULTICALL_ADDRESS,
+            contracts: [...farmInfoCalls, ...farmSupplyCalls, ...rewardTokenCalls],
+        });
+        const mcResponse = mc;
+        const [...restMCResponse] = mcResponse;
+        const farmInfoCallsEnd = farmInfoCalls.length;
+        const farmInfo = restMCResponse.slice(0, farmInfoCallsEnd);
+        const farmSupplyCallsEnd = farmInfoCallsEnd + farmSupplyCalls.length;
+        const farmSupply = restMCResponse.slice(farmInfoCallsEnd, farmSupplyCallsEnd);
+        const rewardTokenCallsEnd = farmSupplyCallsEnd + rewardTokenCalls.length;
+        const rewardTokens = restMCResponse.slice(farmSupplyCallsEnd, rewardTokenCallsEnd);
+        const infoByPool = poolStakedTokens.reduce((acc, p, index) => {
+            const info = farmInfo[index];
+            if (info)
+                acc[p] = info;
+            return acc;
+        }, {});
+        const rewardTokenPool = poolStakedTokens.reduce((acc, p, index) => {
+            const token = rewardTokens[index];
+            if (token) {
+                acc[p] = token.toLowerCase();
+            }
+            return acc;
+        }, {});
+        const stakedTokenRewards = allPoolTokens.reduce((acc, pool) => {
+            const info = infoByPool[pool];
+            const token = rewardTokenPool[pool];
+            const tokenData = tokensList[token];
+            const baseReward = info && tokenData
+                ? {
+                    pool: poolByItsToken[pool],
+                    duration: BigInt(info.duration),
+                    finished: BigInt(info.finished),
+                    reward: info.reward,
+                    balance: info.balance,
+                    symbol: tokenData.symbol,
+                }
+                : undefined;
+            if (baseReward)
+                acc.base[pool] = baseReward;
+            acc.all[pool] = [...(baseReward ? [baseReward] : [])];
+            return acc;
+        }, { base: {}, all: {} });
+        const rewardPoolsSupply = allPoolTokens.reduce((acc, address, i) => {
+            acc[address] = farmSupply[i] || 0n;
+            return acc;
+        }, {});
+        return {
+            rewardPoolsInfo: stakedTokenRewards.all,
+            baseRewardPoolsInfo: stakedTokenRewards.base,
+            rewardPoolsSupply,
+        };
+    }
+    static async getLmRewardsV2({ provider, account, currentTokenData, network, airdropDistributorAddress, }) {
+        if (!airdropDistributorAddress)
+            return { rewards: [] };
+        const [claimedResp, merkleDataResp] = await Promise.all([
+            this.getClaimed({ airdropDistributorAddress, provider, account }),
+            this.getMerkle(provider, airdropDistributorAddress, network, account),
+        ]);
+        const amountOnContract = this.getAmountOnContract({
+            account,
+            merkleData: merkleDataResp,
+        });
+        const diff = amountOnContract - claimedResp;
+        const availableToClaimV2 = math_1.BigIntMath.max(0n, diff);
+        const rewards = [
+            {
+                amount: availableToClaimV2,
+                type: "merkleV2",
+                rewardToken: currentTokenData.GEAR,
+                rewardTokenDecimals: 18,
+                rewardTokenSymbol: "GEAR",
+            },
+        ];
+        return { rewards: rewards };
+    }
+    static async getLmRewardsV3({ pools, baseRewardPoolsInfo, currentTokenData, tokensList, provider, account, network, reportError, }) {
+        const poolTokens = Object.keys(baseRewardPoolsInfo);
+        const [gearboxLmResponse, merkleXYZLMResponse] = await Promise.allSettled([
+            provider.multicall({
+                allowFailure: false,
+                multicallAddress: sdk_gov_1.MULTICALL_ADDRESS,
+                contracts: poolTokens.map(address => ({
+                    address: address,
+                    abi: types_1.iFarmingPoolAbi,
+                    functionName: "farmed",
+                    args: [account],
+                })),
+            }),
+            axios_1.default.get(merklAPI_1.MerkleXYZApi.getUserRewardsUrl({
+                params: {
+                    chainId: sdk_gov_1.CHAINS[network],
+                    user: (0, viem_1.getAddress)(account),
+                },
+            })),
+        ]);
+        const gearboxLm = (this.extractFulfilled(gearboxLmResponse, reportError, "v3Rewards") || []);
+        const merkleXYZLm = this.extractFulfilled(merkleXYZLMResponse, reportError, "merkleRewards")?.data;
+        const poolByItsToken = Object.values(pools).reduce((acc, p) => {
+            p.stakedDieselToken.forEach(t => {
+                if (t)
+                    acc[t] = p.address;
+            });
+            p.stakedDieselToken_old.forEach(t => {
+                if (t)
+                    acc[t] = p.address;
+            });
+            acc[p.dieselToken] = p.address;
+            return acc;
+        }, {});
+        const extraRewards = (merkleXYZLm || []).reduce((acc, chainRewards) => {
+            chainRewards.rewards.forEach(reward => {
+                const rewardToken = reward.token.address.toLowerCase();
+                reward.breakdowns.forEach(reason => {
+                    const poolToken = ((reason.reason || "").split("_")[1] || "").toLowerCase();
+                    const pool = (baseRewardPoolsInfo[poolToken]?.pool ||
+                        poolToken ||
+                        "").toLowerCase();
+                    if (poolByItsToken[poolToken] && poolByItsToken[pool]) {
+                        const total = (0, sdk_gov_1.toBigInt)(reason.amount || 0);
+                        const claimed = (0, sdk_gov_1.toBigInt)(reason.claimed || 0);
+                        acc.push({
+                            pool,
+                            poolToken,
+                            rewardToken,
+                            rewardTokenSymbol: reward.token.symbol,
+                            rewardTokenDecimals: reward.token.decimals || 18,
+                            amount: math_1.BigIntMath.max(total - claimed, 0n),
+                            type: "extraMerkle",
+                        });
+                    }
+                });
+            });
+            return acc;
+        }, []);
+        const gearboxLmRewards = poolTokens.map((address, i) => {
+            const info = baseRewardPoolsInfo[address];
+            const rewardToken = currentTokenData[info.symbol];
+            return {
+                pool: info.pool,
+                poolToken: address,
+                rewardToken,
+                rewardTokenDecimals: tokensList[rewardToken]?.decimals || 18,
+                rewardTokenSymbol: info.symbol,
+                amount: gearboxLm[i] || 0n,
+                type: "stakedV3",
+            };
+        });
+        const { zero, nonZero } = gearboxLmRewards.reduce((acc, r) => {
+            const amount = r.amount || 0n;
+            if (amount > 0n) {
+                acc.nonZero.push(r);
+            }
+            else {
+                acc.zero.push(r);
+            }
+            return acc;
+        }, { nonZero: [], zero: [] });
+        return {
+            rewards: [...nonZero, ...extraRewards, zero],
+        };
+    }
+    static extractFulfilled(r, reportError, description) {
+        if (r.status === "fulfilled") {
+            return r.value;
+        }
+        else {
+            if (reportError) {
+                reportError(r.reason, description);
+            }
+            else {
+                console.error(r.reason);
+            }
+            return undefined;
+        }
+    }
+    static async claimLmRewardsV2({ signer, account, provider, network, airdropDistributorAddress, }) {
+        if (!airdropDistributorAddress)
+            throw new Error(`V2 rewards are not supported on chain: ${network}`);
+        const merkleData = await this.getMerkle(provider, airdropDistributorAddress, network, account);
+        const rewardFromMerkle = merkleData?.claims[(0, viem_1.getAddress)(account)];
+        if (!rewardFromMerkle)
+            throw new Error("No rewards found");
+        const distributor = (0, viem_1.getContract)({
+            address: airdropDistributorAddress,
+            abi: types_1.iAirdropDistributorAbi,
+            client: signer,
+        });
+        return distributor.write.claim([
+            BigInt(rewardFromMerkle.index),
+            account,
+            (0, sdk_gov_1.toBigInt)(rewardFromMerkle.amount),
+            rewardFromMerkle.proof,
+        ], {
+            account: account,
+            chain: signer.chain,
+        });
+    }
+    static async claimLmRewardsV3({ reward, signer, account, }) {
+        const pool = (0, viem_1.getContract)({
+            address: reward.poolToken,
+            abi: types_1.iFarmingPoolAbi,
+            client: signer,
+        });
+        return pool.write.claim({
+            account: account,
+            chain: signer.chain,
+        });
+    }
+    static async getMerkle(provider, distributorAddress, network, account) {
+        const distributor = (0, viem_1.getContract)({
+            address: distributorAddress,
+            abi: types_1.iAirdropDistributorAbi,
+            client: provider,
+        });
+        const root = await distributor.read.merkleRoot();
+        const result = await axios_1.default.get(endpoint_1.GearboxBackendApi.getRewardsMerkleUrl(network, root, account));
+        return result.data;
+    }
+    static async getClaimed({ provider, airdropDistributorAddress, account, }) {
+        const distributor = (0, viem_1.getContract)({
+            address: airdropDistributorAddress,
+            abi: types_1.iAirdropDistributorAbi,
+            client: provider,
+        });
+        const claimedRewardsResponse = await distributor.getEvents.Claimed({
+            account,
+            historic: false,
+        }, {
+            fromBlock: 0n,
+        });
+        const claimedRewards = (claimedRewardsResponse || []).reduce((acc, r) => acc + (r.args.amount || 0n), 0n);
+        return claimedRewards;
+    }
+    static getAmountOnContract({ account, merkleData, }) {
+        const { claims = {} } = merkleData || {};
+        const { amount } = claims[(0, viem_1.getAddress)(account)] || {};
+        return BigInt(amount || 0);
+    }
+}
+exports.GearboxRewardsApi = GearboxRewardsApi;
+const POOL_REWARDS_ABI = [
+    {
+        inputs: [],
+        name: "rewardsToken",
+        outputs: [
+            {
+                internalType: "contract IERC20",
+                name: "",
+                type: "address",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+];

package/lib/gearboxRewards/apy.d.ts

@@ -0,0 +1,53 @@
+import { SupportedToken } from "@gearbox-protocol/sdk-gov";
+import { Address } from "viem";
+import { Asset } from "../core/assets";
+import { PoolData } from "../core/pool";
+import { TokenData } from "../tokens/tokenData";
+import { FarmInfo } from "./api";
+interface CalculateV3PoolLmAPYProps {
+    currentTimestamp: number;
+    info: FarmInfo;
+    supply: {
+        decimals: number;
+        amount: bigint;
+        price: bigint;
+    };
+    reward: {
+        decimals: number;
+        price: bigint;
+    };
+}
+export interface ExtraRewardApy {
+    token: Address;
+    balance: bigint | null;
+    apy: number;
+    rewardToken: Address;
+    rewardTokenSymbol: string;
+}
+interface GetPoolExtraAPY_V3Props {
+    stakedDieselToken: Address | undefined;
+    pool: PoolData;
+    prices: Record<Address, bigint>;
+    rewardPoolsInfo: Record<Address, Array<FarmInfo>>;
+    rewardPoolsSupply: Record<Address, bigint>;
+    tokensList: Record<Address, TokenData>;
+    currentTokenData: Record<SupportedToken, Address>;
+    currentTimestamp: number;
+}
+interface GetCAExtraAPYProps {
+    assets: Array<Asset>;
+    supply: Record<Address, bigint> | Record<Address, Asset>;
+    rewardInfo: Record<Address, Array<FarmInfo>>;
+    currentTimestamp: number;
+    prices: Record<Address, bigint>;
+    tokensList: Record<Address, TokenData>;
+    currentTokenData: Record<SupportedToken, Address>;
+}
+export declare class GearboxRewardsApy {
+    static getPoolExtraAPY_V3({ rewardPoolsInfo, stakedDieselToken, ...restProps }: GetPoolExtraAPY_V3Props): Array<ExtraRewardApy>;
+    private static getPoolSingleExtraLmAPY_V3;
+    static calculateAPY_V3({ info, supply, reward, currentTimestamp, }: CalculateV3PoolLmAPYProps): number;
+    static getCAExtraAPY_V3({ rewardInfo, assets, ...restProps }: GetCAExtraAPYProps): Array<ExtraRewardApy>;
+    private static getCASingleExtraAPY_V3;
+}
+export {};

package/lib/gearboxRewards/apy.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GearboxRewardsApy = void 0;
+const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
+const price_1 = require("../utils/price");
+const PERCENTAGE_FACTOR_1KK = sdk_gov_1.PERCENTAGE_DECIMALS * sdk_gov_1.PERCENTAGE_FACTOR;
+const ONE = PERCENTAGE_FACTOR_1KK * 10n;
+class GearboxRewardsApy {
+    static getPoolExtraAPY_V3({ rewardPoolsInfo, stakedDieselToken, ...restProps }) {
+        const { version } = restProps.pool;
+        const isV3 = version >= 300 && version < 400;
+        if (!isV3 || !stakedDieselToken)
+            return [];
+        const info = rewardPoolsInfo[stakedDieselToken];
+        if (!info)
+            return [];
+        const extra = info.map(inf => this.getPoolSingleExtraLmAPY_V3({
+            ...restProps,
+            stakedDieselToken,
+            rewardPoolsInfo: inf,
+        }));
+        return extra;
+    }
+    static getPoolSingleExtraLmAPY_V3({ stakedDieselToken, pool, prices, rewardPoolsInfo, rewardPoolsSupply, tokensList, currentTokenData, currentTimestamp, }) {
+        const { underlyingToken, dieselRateRay } = pool;
+        const safeSupply = rewardPoolsSupply[stakedDieselToken] ?? 0n;
+        const { decimals: underlyingDecimals = 18 } = tokensList[underlyingToken] || {};
+        const underlyingPrice = prices[underlyingToken] ?? 0n;
+        const dieselPrice = (underlyingPrice * dieselRateRay) / sdk_gov_1.RAY;
+        const rewardAddress = currentTokenData[rewardPoolsInfo.symbol];
+        const { decimals: rewardDecimals = 18 } = tokensList[rewardAddress] || {};
+        const rewardPrice = prices[rewardAddress] ?? 0n;
+        const r = this.calculateAPY_V3({
+            currentTimestamp,
+            info: rewardPoolsInfo,
+            supply: {
+                amount: safeSupply,
+                decimals: underlyingDecimals,
+                price: dieselPrice,
+            },
+            reward: {
+                price: rewardPrice,
+                decimals: rewardDecimals,
+            },
+        }) / Number(sdk_gov_1.PERCENTAGE_FACTOR);
+        return {
+            token: stakedDieselToken,
+            balance: null,
+            apy: r,
+            rewardToken: rewardAddress,
+            rewardTokenSymbol: rewardPoolsInfo.symbol,
+        };
+    }
+    static calculateAPY_V3({ info, supply, reward, currentTimestamp, }) {
+        const finished = info.finished <= currentTimestamp;
+        if (finished)
+            return 0;
+        if (supply.amount <= 0n)
+            return 0;
+        if (supply.price === 0n || reward.price === 0n)
+            return 0;
+        if (info.duration === 0n)
+            return 0;
+        const supplyMoney = price_1.PriceUtils.calcTotalPrice(supply.price, supply.amount, supply.decimals);
+        const rewardMoney = price_1.PriceUtils.calcTotalPrice(reward.price, info.reward, reward.decimals);
+        const durationRatio = ((0, sdk_gov_1.toBigInt)(sdk_gov_1.SECONDS_PER_YEAR) * sdk_gov_1.WAD) / info.duration;
+        const apyBn = (((rewardMoney * ONE) / supplyMoney) * durationRatio) / sdk_gov_1.WAD;
+        return Math.round(Number(apyBn) / 10);
+    }
+    static getCAExtraAPY_V3({ rewardInfo, assets, ...restProps }) {
+        const extra = assets.reduce((acc, asset) => {
+            const { token } = asset;
+            const info = rewardInfo[token || ""];
+            if (!info || info.length === 0)
+                return acc;
+            const extra = info.map(inf => this.getCASingleExtraAPY_V3({
+                ...restProps,
+                asset,
+                rewardInfo: inf,
+            }));
+            acc.push(...extra);
+            return acc;
+        }, []);
+        return extra;
+    }
+    static getCASingleExtraAPY_V3({ asset, prices, rewardInfo, supply, tokensList, currentTokenData, currentTimestamp, }) {
+        const { token, balance } = asset;
+        const safeSupply = supply[token] ?? 0n;
+        const { decimals: tokenDecimals = 18 } = tokensList[token] || {};
+        const tokenPrice = prices[token] ?? 0n;
+        const rewardAddress = currentTokenData[rewardInfo.symbol];
+        const { decimals: rewardDecimals = 18 } = tokensList[rewardAddress] || {};
+        const rewardPrice = prices[rewardAddress] ?? 0n;
+        const r = this.calculateAPY_V3({
+            currentTimestamp,
+            info: rewardInfo,
+            supply: {
+                amount: typeof safeSupply === "bigint" ? safeSupply : safeSupply.balance,
+                decimals: tokenDecimals,
+                price: tokenPrice,
+            },
+            reward: {
+                price: rewardPrice,
+                decimals: rewardDecimals,
+            },
+        }) / Number(sdk_gov_1.PERCENTAGE_FACTOR);
+        return {
+            token,
+            balance,
+            apy: r,
+            rewardToken: rewardAddress,
+            rewardTokenSymbol: rewardInfo.symbol,
+        };
+    }
+}
+exports.GearboxRewardsApy = GearboxRewardsApy;

package/lib/gearboxRewards/extraAPY.d.ts

@@ -0,0 +1,32 @@
+import { NetworkType } from "@gearbox-protocol/sdk-gov";
+import { Address } from "viem";
+import { Asset } from "../core/assets";
+import { PoolData } from "../core/pool";
+import { TokenData } from "../tokens/tokenData";
+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>;
+    tokensList: Record<Address, TokenData>;
+}
+export interface GetTotalTokensOnProtocolProps {
+    tokensToCheck: Array<Address>;
+    tokensList: Record<Address, TokenData>;
+    network: NetworkType;
+}
+export declare class GearboxRewardsExtraApy {
+    static getTotalTokensOnProtocol({ tokensToCheck, tokensList, network, }: GetTotalTokensOnProtocolProps): Promise<[`0x${string}`, PromiseSettledResult<Asset>][]>;
+    private static getTokenTotal;
+    static getPointsByPool({ poolRewards, totalTokenBalances, pools, tokensList, }: GetPointsByPoolProps): Record<`0x${string}`, Asset[]>;
+    private static getPoolTokenPoints;
+    static getPoolPointsTip(poolRewards: Record<Address, Record<Address, PoolPointsInfo>>, pool: Address, token: Address): PoolPointsInfo;
+}