@gearbox-protocol/sdk 3.0.0-next.20 → 3.0.0-next.201

package/lib/gearboxRewards/api.d.ts

@@ -0,0 +1,86 @@
+import { ExcludeArrayProps, NetworkType, SupportedToken } from "@gearbox-protocol/sdk-gov";
+import { BytesLike, Provider, Signer } from "ethers";
+import { FarmAccounting } from "../types/IFarmingPool";
+export interface GearboxExtraMerkleLmReward {
+    poolToken: string;
+    rewardToken: string;
+    amount: bigint;
+    type: "extraMerkle";
+}
+export interface GearboxStakedV3LmReward {
+    poolToken: string;
+    rewardToken: string;
+    amount: bigint;
+    type: "stakedV3";
+}
+export interface GearboxMerkleV2LmReward {
+    poolToken?: string;
+    rewardToken: string;
+    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<BytesLike>;
+    }>;
+}
+type FarmInfoOutput = ExcludeArrayProps<FarmAccounting.InfoStructOutput>;
+export type FarmInfo = FarmInfoOutput & {
+    symbol: SupportedToken;
+};
+type PoolsWithExtraRewardsList = Record<NetworkType, Array<SupportedToken>>;
+type ReportHandler = (e: unknown, description?: string) => void;
+export interface GetLmRewardsInfoProps {
+    currentTokenData: Record<SupportedToken, string>;
+    provider: Provider | Signer;
+    multicallAddress: string;
+    poolsWithExtraRewards?: PoolsWithExtraRewardsList;
+    network: NetworkType;
+    reportError?: ReportHandler;
+}
+export interface GetLmRewardsProps {
+    baseRewardPoolsInfo: Record<string, FarmInfo>;
+    currentTokenData: Record<SupportedToken, string>;
+    account: string;
+    provider: Provider | Signer;
+    airdropDistributorAddress: string | undefined;
+    network: NetworkType;
+    reportError?: ReportHandler;
+}
+export interface ClaimLmRewardsV2Props {
+    signer: Signer;
+    account: string;
+    provider: Provider;
+    airdropDistributorAddress: string | undefined;
+    network: NetworkType;
+}
+export interface ClaimLmRewardsV3Props {
+    reward: GearboxStakedV3LmReward;
+    signer: Signer;
+}
+export declare class GearboxRewardsApi {
+    static getLmRewardsInfo({ currentTokenData, provider, multicallAddress, poolsWithExtraRewards, network, reportError, }: GetLmRewardsInfoProps): Promise<{
+        rewardPoolsInfo: Record<string, FarmInfo[]>;
+        baseRewardPoolsInfo: Record<string, FarmInfo>;
+        extraRewardPoolsInfo: Record<string, FarmInfo[]>;
+        rewardPoolsSupply: Record<string, bigint>;
+    }>;
+    static getLmRewardsV2({ provider, account, currentTokenData, network, airdropDistributorAddress, }: GetLmRewardsProps): Promise<{
+        rewards: GearboxLmReward[];
+    }>;
+    static getLmRewardsV3({ baseRewardPoolsInfo, currentTokenData, provider, account, network, reportError, }: GetLmRewardsProps): Promise<{
+        rewards: (GearboxLmReward | GearboxLmReward[])[];
+    }>;
+    private static extractFulfilled;
+    static claimLmRewardsV2({ signer, account, provider, network, airdropDistributorAddress, }: ClaimLmRewardsV2Props): Promise<import("ethers").TransactionResponse | import("../utils/calls").MinimalTxInfo>;
+    static claimLmRewardsV3({ reward, signer }: ClaimLmRewardsV3Props): Promise<import("ethers").TransactionResponse | import("../utils/calls").MinimalTxInfo>;
+    private static getMerkle;
+    private static getClaimed;
+    private static getAmountOnContract;
+}
+export {};

package/lib/gearboxRewards/api.js

@@ -0,0 +1,279 @@
+"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 ethers_1 = require("ethers");
+const types_1 = require("../types");
+const calls_1 = require("../utils/calls");
+const formatter_1 = require("../utils/formatter");
+const math_1 = require("../utils/math");
+const abi_1 = require("./abi");
+const merklAPI_1 = require("./merklAPI");
+const DEFAULT_POOLS_WITH_EXTRA_REWARDS = {
+    Mainnet: ["sdcrvUSDV3"],
+    Arbitrum: [],
+    Optimism: [],
+    Base: [],
+};
+class GearboxRewardsApi {
+    static async getLmRewardsInfo({ currentTokenData, provider, multicallAddress, poolsWithExtraRewards = DEFAULT_POOLS_WITH_EXTRA_REWARDS, network, reportError, }) {
+        const poolTokens = sdk_gov_1.TypedObjectUtils.entries(currentTokenData).filter(([symbol]) => (0, sdk_gov_1.isDieselStakedToken)(symbol));
+        const farmInfoCalls = poolTokens.map(([, address]) => ({
+            address: address,
+            interface: types_1.IFarmingPool__factory.createInterface(),
+            method: "farmInfo()",
+        }));
+        const rewardTokenCalls = poolTokens.map(([, address]) => ({
+            address: address,
+            interface: POOL_REWARD_INTERFACE,
+            method: "rewardsToken()",
+        }));
+        const farmSupplyCalls = poolTokens.map(([, address]) => ({
+            address: address,
+            interface: types_1.IFarmingPool__factory.createInterface(),
+            method: "totalSupply()",
+            params: [],
+        }));
+        const blockTimestampCall = {
+            address: multicallAddress,
+            interface: abi_1.MULTICALL_EXTENDED_INTERFACE,
+            method: "getCurrentBlockTimestamp()",
+        };
+        const tokenWithExtraRewards = poolsWithExtraRewards[network] || [];
+        const chainId = sdk_gov_1.CHAINS[network];
+        const [mc, ...extra] = await Promise.allSettled([
+            (0, sdk_gov_1.multicall)([
+                blockTimestampCall,
+                ...farmInfoCalls,
+                ...farmSupplyCalls,
+                ...rewardTokenCalls,
+            ], provider),
+            ...tokenWithExtraRewards.map(symbol => axios_1.default.get(merklAPI_1.MerkleXYZApi.getRewardsCampaignsUrl({
+                params: {
+                    chainId,
+                    mainParameter: (0, ethers_1.getAddress)(currentTokenData[symbol]),
+                },
+            }))),
+        ]);
+        const mcResponse = this.extractFulfilled(mc, reportError, "rewardsInfoMulticall") || [];
+        const [blockTimestamp = 0n, ...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 extraRewards = extra.reduce((acc, r, index) => {
+            const stakedSymbol = tokenWithExtraRewards[index];
+            const safeResp = this.extractFulfilled(r, reportError, `merkleCampaign: ${stakedSymbol}`);
+            const l = safeResp?.data.reduce((infos, d) => {
+                const started = (0, sdk_gov_1.toBigInt)(d.startTimestamp || 0);
+                const finished = (0, sdk_gov_1.toBigInt)(d.endTimestamp || 0);
+                if (blockTimestamp >= started && blockTimestamp <= finished) {
+                    const rewardTokenLc = (d.rewardToken || "").toLowerCase();
+                    const [rewardSymbol, decimals = 18] = (0, sdk_gov_1.extractTokenData)(rewardTokenLc);
+                    const reward = (0, formatter_1.toBN)(d.amountDecimal, decimals);
+                    if (rewardSymbol && reward > 0) {
+                        infos.push({
+                            duration: (0, sdk_gov_1.toBigInt)(d.endTimestamp - d.startTimestamp),
+                            finished,
+                            reward,
+                            balance: 0n,
+                            symbol: rewardSymbol,
+                        });
+                    }
+                }
+                return infos;
+            }, []);
+            if (l) {
+                acc[currentTokenData[stakedSymbol]] = l;
+            }
+            return acc;
+        }, {});
+        const rewardPoolsInfo = poolTokens.reduce((acc, [, address], i) => {
+            const currentInfo = farmInfo[i];
+            const [symbol] = (0, sdk_gov_1.extractTokenData)(rewardTokens[i] || "");
+            if (symbol) {
+                const baseReward = {
+                    duration: currentInfo.duration,
+                    finished: currentInfo.finished,
+                    reward: currentInfo.reward,
+                    balance: currentInfo.balance,
+                    symbol: symbol,
+                };
+                const extra = extraRewards[address] || [];
+                acc.base[address] = baseReward;
+                acc.extra[address] = extra;
+                acc.all[address] = [baseReward, ...extra];
+            }
+            return acc;
+        }, { base: {}, extra: {}, all: {} });
+        const rewardPoolsSupply = poolTokens.reduce((acc, [, address], i) => {
+            acc[address] = farmSupply[i] || 0n;
+            return acc;
+        }, {});
+        return {
+            rewardPoolsInfo: rewardPoolsInfo.all,
+            baseRewardPoolsInfo: rewardPoolsInfo.base,
+            extraRewardPoolsInfo: rewardPoolsInfo.extra,
+            rewardPoolsSupply,
+        };
+    }
+    static async getLmRewardsV2({ provider, account, currentTokenData, network, airdropDistributorAddress, }) {
+        if (!airdropDistributorAddress)
+            return { rewards: [] };
+        const distributor = types_1.IAirdropDistributor__factory.connect(airdropDistributorAddress, provider);
+        const [claimedResp, merkleDataResp] = await Promise.all([
+            this.getClaimed({ distributor, 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,
+            },
+        ];
+        return { rewards: rewards };
+    }
+    static async getLmRewardsV3({ baseRewardPoolsInfo, currentTokenData, provider, account, network, reportError, }) {
+        const poolTokens = Object.keys(baseRewardPoolsInfo);
+        const farmedCalls = poolTokens.map(address => ({
+            address: address,
+            interface: types_1.IFarmingPool__factory.createInterface(),
+            method: "farmed(address)",
+            params: [account],
+        }));
+        const [gearboxLmResponse, merkleXYZLMResponse] = await Promise.allSettled([
+            (0, sdk_gov_1.multicall)(farmedCalls, provider),
+            axios_1.default.get(merklAPI_1.MerkleXYZApi.getUserRewardsUrl({
+                params: {
+                    chainId: sdk_gov_1.CHAINS[network],
+                    user: (0, ethers_1.getAddress)(account),
+                },
+            })),
+        ]);
+        const gearboxLm = this.extractFulfilled(gearboxLmResponse, reportError, "v3Rewards") || [];
+        const merkleXYZLM = this.extractFulfilled(merkleXYZLMResponse, reportError, "merkleRewards")?.data;
+        const PREFIX = "ERC20";
+        const REWARD_KEYS_RECORD = poolTokens.reduce((acc, t) => {
+            const key = [PREFIX, (0, ethers_1.getAddress)(t)].join("_");
+            acc[key] = t;
+            return acc;
+        }, {});
+        const extraRewards = Object.entries(merkleXYZLM || {}).reduce((acc, [k, v]) => {
+            const rewardToken = k.toLowerCase();
+            Object.entries(v.reasons).forEach(([key, reason]) => {
+                const poolToken = REWARD_KEYS_RECORD[key];
+                if (poolToken && sdk_gov_1.tokenSymbolByAddress[rewardToken]) {
+                    acc.push({
+                        poolToken,
+                        rewardToken,
+                        amount: (0, sdk_gov_1.toBigInt)(reason.unclaimed || 0n),
+                        type: "extraMerkle",
+                    });
+                }
+            });
+            return acc;
+        }, []);
+        const gearboxLmRewards = poolTokens.map((address, i) => {
+            return {
+                poolToken: address,
+                rewardToken: currentTokenData[baseRewardPoolsInfo[address].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 distributor = types_1.IAirdropDistributor__factory.connect(airdropDistributorAddress, signer);
+        const merkleData = await this.getMerkle(provider, airdropDistributorAddress, network, account);
+        const rewardFromMerkle = merkleData?.claims[account];
+        if (!rewardFromMerkle)
+            throw new Error("No rewards found");
+        return (0, calls_1.makeTransactionCall)(distributor.claim, [
+            rewardFromMerkle.index,
+            account,
+            rewardFromMerkle.amount,
+            rewardFromMerkle.proof,
+        ], signer);
+    }
+    static async claimLmRewardsV3({ reward, signer }) {
+        const pool = types_1.IFarmingPool__factory.connect(reward.poolToken, signer);
+        return (0, calls_1.makeTransactionCall)(pool.claim, [], signer);
+    }
+    static async getMerkle(provider, distributorAddress, network, account) {
+        const distributor = types_1.IAirdropDistributor__factory.connect(distributorAddress, provider);
+        const root = await distributor.merkleRoot();
+        const path = `${network}_${root.slice(2)}/${account.slice(2, 4)}`;
+        const url = `https://am.gearbox.finance/${path.toLowerCase()}.json`;
+        const result = await axios_1.default.get(url);
+        return result.data;
+    }
+    static async getClaimed({ distributor, account, }) {
+        const claimedRewardsResponse = await distributor.queryFilter(distributor.filters.Claimed(account, undefined, false));
+        const claimedRewards = (claimedRewardsResponse || []).reduce((acc, r) => acc + r.args.amount, 0n);
+        return claimedRewards;
+    }
+    static getAmountOnContract({ account, merkleData, }) {
+        const { claims = {} } = merkleData || {};
+        const { amount } = claims[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",
+    },
+];
+const POOL_REWARD_INTERFACE = new ethers_1.Interface(POOL_REWARDS_ABI);

package/lib/gearboxRewards/apy.d.ts

@@ -0,0 +1,37 @@
+import { SupportedToken } from "@gearbox-protocol/sdk-gov";
+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 PoolExtraRewardApy {
+    symbol: SupportedToken;
+    apy: number;
+}
+interface GetPoolExtraAPY_V3Props {
+    stakedDieselToken: string | undefined;
+    pool: PoolData;
+    prices: Record<string, bigint>;
+    rewardPoolsInfo: Record<string, Array<FarmInfo>>;
+    rewardPoolsSupply: Record<string, bigint>;
+    tokensList: Record<string, TokenData>;
+    currentTokenData: Record<SupportedToken, string>;
+    currentTimestamp: number;
+}
+export declare class GearboxRewardsApy {
+    static getPoolExtraAPY_V3({ rewardPoolsInfo, stakedDieselToken, ...restProps }: GetPoolExtraAPY_V3Props): Array<PoolExtraRewardApy>;
+    private static getPoolSingleExtraLmAPY_V3;
+    static calculateAPY_V3({ info, supply, reward, currentTimestamp, }: CalculateV3PoolLmAPYProps): number;
+}
+export {};

package/lib/gearboxRewards/apy.js

@@ -0,0 +1,65 @@
+"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 { symbol: rewardPoolsInfo.symbol, apy: r };
+    }
+    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);
+    }
+}
+exports.GearboxRewardsApy = GearboxRewardsApy;

package/lib/gearboxRewards/extraAPY.d.ts

@@ -0,0 +1,32 @@
+import { NetworkType, SupportedToken } from "@gearbox-protocol/sdk-gov";
+import { Asset } from "../core/assets";
+import { PoolData } from "../core/pool";
+import { TokenData } from "../tokens/tokenData";
+export interface GetPointsByPoolProps {
+    totalTokenBalances: Record<string, Asset>;
+    pools: Array<PoolData>;
+    currentTokenData: Record<SupportedToken, string>;
+    tokensList: Record<string, TokenData>;
+    network: NetworkType;
+}
+export interface GetTotalTokensOnProtocolProps {
+    currentTokenData: Record<SupportedToken, string>;
+    tokensList: Record<string, TokenData>;
+    chainId: number;
+    network: NetworkType;
+}
+interface PoolPointsInfo {
+    amount: bigint;
+    symbol: SupportedToken;
+    duration: string;
+    name: string;
+}
+export declare class GearboxRewardsExtraApy {
+    static getTotalTokensOnProtocol({ currentTokenData, chainId, tokensList, network, }: GetTotalTokensOnProtocolProps): Promise<[SupportedToken, PromiseSettledResult<Asset>][]>;
+    private static getTokenTotal;
+    static getPointsByPool({ totalTokenBalances, pools, tokensList, currentTokenData, network, }: GetPointsByPoolProps): Record<string, Asset[]>;
+    private static getPoolTokenPoints;
+    static getPoolPointsTip(network: NetworkType, pool: string, token: SupportedToken): PoolPointsInfo | undefined;
+    static getExtraLidoAPY: (supply: bigint, supplyPrice: bigint, rewardPrice: bigint, currentTimestamp: number) => number;
+}
+export {};

package/lib/gearboxRewards/extraAPY.js

@@ -0,0 +1,132 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GearboxRewardsExtraApy = void 0;
+const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
+const axios_1 = __importDefault(require("axios"));
+const contractsRegister_1 = require("../contracts/contractsRegister");
+const endpoint_1 = require("../core/endpoint");
+const formatter_1 = require("../utils/formatter");
+const math_1 = require("../utils/math");
+const apy_1 = require("./apy");
+const POOL_POINTS = {
+    Mainnet: {
+        [contractsRegister_1.poolByNetwork.Mainnet.WETH_V3_TRADE]: {
+            // !& ezeth
+            // ezETH: {
+            //   amount: PERCENTAGE_FACTOR,
+            //   symbol: "ezETH",
+            //   duration: "hour",
+            //   name: "ezPoint",
+            // },
+            rsETH: {
+                amount: 7500n * 10000n,
+                symbol: "rsETH",
+                duration: "hour",
+                name: "Kelp Mile",
+            },
+        },
+    },
+    Arbitrum: {
+    // [poolByNetwork.Arbitrum.WETH_V3]: {
+    //   ezETH: {
+    //     amount: PERCENTAGE_FACTOR,
+    //     symbol: "ezETH",
+    //     duration: "hour",
+    //     name: "ezPoint",
+    //   },
+    // },
+    },
+    Optimism: {},
+    Base: {},
+};
+// !& + STETH
+const TOKENS = sdk_gov_1.TypedObjectUtils.entries(POOL_POINTS).reduce((acc, [network, pools]) => {
+    const r = Object.values(pools).reduce((acc, tokens) => {
+        const l = Object.keys(tokens);
+        acc.push(...l);
+        return acc;
+    }, []);
+    acc[network] = r;
+    return acc;
+}, {});
+const REWARD = (0, formatter_1.toBN)("7.7", sdk_gov_1.decimals.wstETH);
+const REWARD_PERIOD = BigInt(30 * 24 * 60 * 60);
+class GearboxRewardsExtraApy {
+    static async getTotalTokensOnProtocol({ currentTokenData, chainId, tokensList, network, }) {
+        const currTokens = TOKENS[network];
+        const res = await Promise.allSettled(currTokens.map(s => this.getTokenTotal(currentTokenData[s], chainId, tokensList)));
+        return res.map((r, i) => [
+            currTokens[i],
+            r,
+        ]);
+    }
+    static async getTokenTotal(token, chainId, tokensList) {
+        const url = endpoint_1.ChartsApi.getUrl("getBalanceAt", chainId, {
+            params: {
+                asset: token,
+            },
+        });
+        const result = await axios_1.default.get(url);
+        const balance = result.data.result.reduce((sum, r) => r.effective_balance + sum, 0);
+        const { decimals = 18 } = tokensList[token] || {};
+        return { token, balance: (0, formatter_1.toBN)(String(balance), decimals) };
+    }
+    static getPointsByPool({ totalTokenBalances, pools, tokensList, currentTokenData, network, }) {
+        const r = pools.reduce((acc, p) => {
+            const poolPointsInfo = Object.values(POOL_POINTS[network]?.[p.address] || []);
+            const poolPointsList = poolPointsInfo.reduce((acc, pointsInfo) => {
+                const tokenBalance = totalTokenBalances[currentTokenData[pointsInfo.symbol] || ""];
+                const points = this.getPoolTokenPoints(tokenBalance, p, tokensList, pointsInfo);
+                if (points !== null) {
+                    acc.push({ balance: points, token: tokenBalance.token });
+                }
+                return acc;
+            }, []);
+            acc[p.address] = poolPointsList;
+            return acc;
+        }, {});
+        return r;
+    }
+    static getPoolTokenPoints(tokenBalanceInPool, pool, tokensList, pointsInfo) {
+        if (!tokenBalanceInPool)
+            return null;
+        if (pool.expectedLiquidity <= 0)
+            return 0n;
+        const { decimals = 18 } = tokensList[tokenBalanceInPool.token] || {};
+        const targetFactor = 10n ** BigInt(decimals);
+        const { decimals: underlyingDecimals = 18 } = tokensList[pool.underlyingToken] || {};
+        const underlyingFactor = 10n ** BigInt(underlyingDecimals);
+        const defaultPoints = (pointsInfo.amount * targetFactor) / sdk_gov_1.PERCENTAGE_FACTOR;
+        const points = (tokenBalanceInPool.balance * defaultPoints) /
+            ((pool.expectedLiquidity * targetFactor) / underlyingFactor);
+        return math_1.BigIntMath.min(points, defaultPoints);
+    }
+    static getPoolPointsTip(network, pool, token) {
+        const p = POOL_POINTS[network]?.[pool]?.[token];
+        return p;
+    }
+    static getExtraLidoAPY = (supply, supplyPrice, rewardPrice, currentTimestamp) => apy_1.GearboxRewardsApy.calculateAPY_V3({
+        info: {
+            balance: 0n,
+            duration: REWARD_PERIOD,
+            // !& + STETH
+            finished: BigInt(Math.floor(Date.now() / 1000) + 10000),
+            reward: REWARD,
+            symbol: "STETH",
+        },
+        supply: {
+            amount: supply,
+            decimals: sdk_gov_1.decimals.wstETH,
+            price: supplyPrice,
+        },
+        reward: {
+            price: rewardPrice,
+            decimals: sdk_gov_1.decimals.wstETH,
+        },
+        currentTimestamp,
+    });
+}
+exports.GearboxRewardsExtraApy = GearboxRewardsExtraApy;

package/lib/gearboxRewards/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./abi";
+export * from "./api";
+export * from "./apy";
+export * from "./extraAPY";

package/lib/gearboxRewards/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./abi"), exports);
+__exportStar(require("./api"), exports);
+__exportStar(require("./apy"), exports);
+__exportStar(require("./extraAPY"), exports);