@gearbox-protocol/sdk 3.0.0-next.99 → 3.0.0-prevfour.10

package/lib/core/{rewardConvex.spec.js → rewardClaimer/rewardConvex.spec.js}

@@ -2,7 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
 const chai_1 = require("chai");
-const ethers_1 = require("ethers");
+const viem_1 = require("viem");
+const types_1 = require("../../types");
 const rewardConvex_1 = require("./rewardConvex");
 const ADAPTER_CONVEX_3CRV_POOL = sdk_gov_1.DUMB_ADDRESS;
 const ADAPTER_CURVE_FRAX_POOL = sdk_gov_1.DUMB_ADDRESS2;
@@ -23,11 +24,6 @@ describe("RewardConvex test", () => {
                 contractAddress: sdk_gov_1.contractsByNetwork.Mainnet.CONVEX_3CRV_POOL,
                 adapter: ADAPTER_CONVEX_3CRV_POOL,
             },
-            // {
-            //   contract: "CONVEX_FRAX3CRV_POOL",
-            //   contractAddress: contractsByNetwork.Goerli.CONVEX_FRAX3CRV_POOL,
-            //   adapter: ADAPTER_CONVEX_FRAX3CRV_POOL,
-            // },
         ];
         const result = rewardConvex_1.RewardConvex.findAdapters(cm);
         (0, chai_1.expect)(result).to.be.eql(expectedResult);
@@ -41,25 +37,22 @@ describe("RewardConvex test", () => {
             },
         };
         const calls = [
-            {
-                address: sdk_gov_1.contractsByNetwork.Mainnet.CONVEX_3CRV_POOL,
-                interface: rewardConvex_1.RewardConvex.poolInterface,
-                method: "earned(address)",
-                params: [CREDIT_ACCOUNT],
-            },
-            // {
-            //   address: contractsByNetwork.Goerli.CONVEX_FRAX3CRV_POOL,
-            //   interface: RewardConvex.poolInterface,
-            //   method: "earned(address)",
-            //   params: [CREDIT_ACCOUNT],
-            // },
-            // {
-            //   address: (contractParams.CONVEX_FRAX3CRV_POOL as ConvexPoolParams)
-            //     .extraRewards[0].poolAddress.Mainnet,
-            //   interface: RewardConvex.poolInterface,
-            //   method: "earned(address)",
-            //   params: [CREDIT_ACCOUNT],
-            // },
+            [
+                {
+                    address: sdk_gov_1.tokenDataByNetwork.Mainnet.CVX,
+                    abi: types_1.iConvexTokenAbi,
+                    functionName: "totalSupply",
+                    args: [],
+                },
+            ],
+            [
+                {
+                    address: sdk_gov_1.contractsByNetwork.Mainnet.CONVEX_3CRV_POOL,
+                    abi: types_1.iBaseRewardPoolAbi,
+                    functionName: "earned",
+                    args: [CREDIT_ACCOUNT],
+                },
+            ],
         ];
         const distribution = [
             {
@@ -67,56 +60,44 @@ describe("RewardConvex test", () => {
                 contractAddress: sdk_gov_1.contractsByNetwork.Mainnet.CONVEX_3CRV_POOL,
                 contract: "CONVEX_3CRV_POOL",
                 token: "CRV",
+                protocol: sdk_gov_1.Protocols.Convex,
             },
-            // {
-            //   adapter: ADAPTER_CONVEX_FRAX3CRV_POOL,
-            //   contractAddress: contractsByNetwork.Goerli.CONVEX_FRAX3CRV_POOL,
-            //   contract: "CONVEX_FRAX3CRV_POOL",
-            //   token: "CRV",
-            // },
-            // {
-            //   adapter: ADAPTER_CONVEX_FRAX3CRV_POOL,
-            //   contractAddress: contractsByNetwork.Goerli.CONVEX_FRAX3CRV_POOL,
-            //   contract: "CONVEX_FRAX3CRV_POOL",
-            //   token: "FXS",
-            // },
         ];
         const result = rewardConvex_1.RewardConvex.prepareMultiCalls(CREDIT_ACCOUNT, cm, "Mainnet");
-        (0, chai_1.expect)(result).to.be.eql({ calls, distribution });
+        (0, chai_1.expect)(result?.convexDistribution).to.be.eql([distribution]);
+        (0, chai_1.expect)(result?.convexCalls).to.be.eql(calls);
     });
     it("parseResults parse data correctly", () => {
-        const rewards = [
-            ethers_1.BigNumber.from(1000n),
-            // BigNumber.from(2000n),
-            // BigNumber.from(4000n),
-        ];
+        const rewards = [1000n];
         const distribution = [
             {
                 adapter: ADAPTER_CONVEX_3CRV_POOL,
                 contractAddress: sdk_gov_1.contractsByNetwork.Mainnet.CONVEX_3CRV_POOL,
                 contract: "CONVEX_3CRV_POOL",
                 token: "CRV",
+                protocol: sdk_gov_1.Protocols.Convex,
             },
-            // {
-            //   adapter: ADAPTER_CONVEX_FRAX3CRV_POOL,
-            //   contractAddress: contractsByNetwork.Goerli.CONVEX_FRAX3CRV_POOL,
-            //   contract: "CONVEX_FRAX3CRV_POOL",
-            //   token: "CRV",
-            // },
-            // {
-            //   adapter: ADAPTER_CONVEX_FRAX3CRV_POOL,
-            //   contractAddress: contractsByNetwork.Goerli.CONVEX_FRAX3CRV_POOL,
-            //   contract: "CONVEX_FRAX3CRV_POOL",
-            //   token: "FXS",
-            // },
         ];
-        const parsed = rewardConvex_1.RewardConvex.parseResults(rewards, distribution);
-        const callData = rewardConvex_1.RewardConvex.poolInterface.encodeFunctionData("getReward()");
+        const parsed = rewardConvex_1.RewardConvex.parseResults({
+            convexDistribution: [distribution],
+            convexResponse: rewards,
+            convexTotalSupply: 0n,
+            auraDistribution: [],
+            auraResponse: [],
+            auraTotalSupply: 0n,
+        });
+        const callData = (0, viem_1.encodeFunctionData)({
+            abi: types_1.iBaseRewardPoolAbi,
+            functionName: "getReward",
+            args: [],
+        });
         const expected = [
             {
+                protocol: sdk_gov_1.Protocols.Convex,
                 contract: "CONVEX_3CRV_POOL",
                 rewards: {
                     CRV: 1000n,
+                    CVX: 1000n,
                 },
                 calls: [
                     {
@@ -125,19 +106,6 @@ describe("RewardConvex test", () => {
                     },
                 ],
             },
-            // {
-            //   contract: "CONVEX_FRAX3CRV_POOL",
-            //   rewards: {
-            //     CRV: 2000n,
-            //     FXS: 4000n,
-            //   },
-            //   calls: [
-            //     {
-            //       target: ADAPTER_CONVEX_FRAX3CRV_POOL,
-            //       callData,
-            //     },
-            //   ],
-            // },
         ];
         (0, chai_1.expect)(parsed).to.be.eql(expected);
     });

package/lib/core/rewardClaimer/stakingRewards.d.ts

@@ -0,0 +1,34 @@
+import { SupportedToken } from "@gearbox-protocol/sdk-gov";
+import { Abi, Address, PublicClient } from "viem";
+import { CreditAccountData } from "../creditAccount";
+import { CreditManagerData } from "../creditManager";
+import { AdapterWithType, Rewards } from "../rewardClaimer";
+type DistributionList = Array<Array<RewardDistribution>>;
+type CallsList = Array<Array<{
+    address: Address;
+    abi: Abi;
+    functionName: string;
+    args: unknown[];
+}>>;
+export interface RewardDistribution {
+    contract: Rewards["contract"];
+    protocol: Rewards["protocol"];
+    token: SupportedToken;
+    adapter: Address;
+    contractAddress: Address;
+}
+export declare class StakingRewards {
+    static findRewards(ca: CreditAccountData, provider: PublicClient, adapters: Array<AdapterWithType>, rewardTokens: Array<Address | undefined>): Promise<Array<Rewards>>;
+    static getRewardTokenCalls(cm: CreditManagerData): {
+        calls: CallsList;
+        adapters: AdapterWithType[];
+    };
+    private static findAdapters;
+    static prepareMultiCalls(creditAccount: Address, adapters: Array<AdapterWithType>, rewardTokens: Array<Address | undefined>): {
+        distribution: DistributionList;
+        calls: CallsList;
+    } | undefined;
+    private static parseResults;
+    private static getRewardObject;
+}
+export {};

package/lib/core/rewardClaimer/stakingRewards.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StakingRewards = void 0;
+const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
+const viem_1 = require("viem");
+const types_1 = require("../../types");
+class StakingRewards {
+    static async findRewards(ca, provider, adapters, rewardTokens) {
+        const prepared = StakingRewards.prepareMultiCalls(ca.creditAccount, adapters, rewardTokens);
+        if (!prepared)
+            return [];
+        const { calls, distribution } = prepared;
+        const callsTotal = calls.flat(1);
+        const allCalls = [...callsTotal];
+        if (allCalls.length === 0)
+            return [];
+        const response = (await provider.multicall({
+            allowFailure: false,
+            multicallAddress: sdk_gov_1.MULTICALL_ADDRESS,
+            contracts: allCalls,
+        }));
+        const callsEnd = callsTotal.length;
+        const callsResponse = response.slice(0, callsEnd);
+        const results = StakingRewards.parseResults(callsResponse, distribution);
+        return results;
+    }
+    static getRewardTokenCalls(cm) {
+        const adapters = this.findAdapters(cm);
+        const calls = adapters.reduce((acc, a) => {
+            acc.push([
+                {
+                    address: a.adapter,
+                    abi: types_1.iStakingRewardsAdapterAbi,
+                    functionName: "rewardsToken",
+                    args: [],
+                },
+            ]);
+            return acc;
+        }, []);
+        return { calls, adapters };
+    }
+    static findAdapters(cm) {
+        const contractsRecord = sdk_gov_1.TypedObjectUtils.entries(sdk_gov_1.contractParams).reduce((acc, [token, params]) => {
+            if (params.type === sdk_gov_1.AdapterInterface.STAKING_REWARDS) {
+                acc[token] = params;
+            }
+            return acc;
+        }, {});
+        return Object.entries(cm.adapters)
+            .filter(([contract]) => !!contractsRecord[sdk_gov_1.contractsByAddress[contract.toLowerCase()]])
+            .map(([contract, adapter]) => ({
+            adapter,
+            contractAddress: contract,
+            contract: sdk_gov_1.contractsByAddress[contract.toLowerCase()],
+        }));
+    }
+    static prepareMultiCalls(creditAccount, adapters, rewardTokens) {
+        if (adapters.length === 0)
+            return undefined;
+        const res = adapters.reduce((acc, a, i) => {
+            const currentContract = sdk_gov_1.contractParams[a.contract];
+            const rewardToken = rewardTokens[i]?.toLowerCase();
+            const currentCalls = [];
+            const currentDistribution = [];
+            if (rewardToken && rewardToken !== sdk_gov_1.ADDRESS_0X0) {
+                // since we generate 1 call above
+                currentCalls.push({
+                    address: a.contractAddress,
+                    abi: types_1.iBaseRewardPoolAbi,
+                    functionName: "earned",
+                    args: [creditAccount],
+                });
+                currentDistribution.push({
+                    protocol: currentContract.protocol,
+                    contract: a.contract,
+                    token: sdk_gov_1.tokenSymbolByAddress[rewardToken],
+                    contractAddress: a.contractAddress,
+                    adapter: a.adapter,
+                });
+                acc.calls.push(currentCalls);
+                acc.distribution.push(currentDistribution);
+            }
+            return acc;
+        }, {
+            distribution: [],
+            calls: [],
+        });
+        return res;
+    }
+    static parseResults(response, distribution) {
+        const rewardsRecord = {};
+        let start = 0;
+        distribution.forEach(list => {
+            // rewards[]
+            const end = start + list.length;
+            const rewardsResp = response.slice(start, end);
+            start = end;
+            if (rewardsResp.length !== list.length) {
+                throw new Error(`Rewards response length mismatch: expected: ${list.length}, got: ${rewardsResp.length}`);
+            }
+            const rewardObject = this.getRewardObject(rewardsResp[0] || 0n, list[0]);
+            if (rewardObject)
+                rewardsRecord[list[0].contract] = rewardObject;
+        });
+        const result = Object.values(rewardsRecord);
+        return result;
+    }
+    static getRewardObject(reward, distribution) {
+        const callData = (0, viem_1.encodeFunctionData)({
+            abi: types_1.iBaseRewardPoolAbi,
+            functionName: "getReward",
+            args: [],
+        });
+        const base = {
+            contract: distribution.contract,
+            protocol: distribution.protocol,
+            rewards: {
+                [distribution.token]: reward,
+            },
+            calls: [
+                {
+                    target: distribution.adapter,
+                    callData,
+                },
+            ],
+        };
+        if (Object.values(base.rewards).some(r => r > 0)) {
+            return base;
+        }
+        return undefined;
+    }
+}
+exports.StakingRewards = StakingRewards;

package/lib/core/strategy.d.ts

@@ -1,31 +1,18 @@
+import { NetworkType, PartialRecord } from "@gearbox-protocol/sdk-gov";
+import { Address } from "viem";
 import { CreditManagerData } from "./creditManager";
-export interface StrategyPayload {
-    apy?: number;
-    name: string;
-    lpToken: string;
-    creditManagers: Array<string>;
-    baseAssets: Array<string>;
-    unleveragableCollateral: Array<string>;
-    leveragableCollateral: Array<string>;
-}
+export type ReleaseAt = undefined | number | PartialRecord<NetworkType, number>;
 interface CalculateMaxAPYProps {
     apy: number;
     leverage: number;
     baseRateWithFee: number;
     quotaRateWithFee: number;
 }
-export declare class Strategy {
-    apy: number | undefined;
-    name: string;
-    lpToken: string;
-    baseAssets: Array<string>;
-    unleveragableCollateral: Array<string>;
-    leveragableCollateral: Array<string>;
-    creditManagers: Array<string>;
-    constructor(payload: StrategyPayload);
-    static maxLeverage(lpToken: string, cms: Array<PartialCM>): number;
+export declare class PositionUtils {
+    static maxLeverage(lpToken: Address, cms: Array<PartialCM>): number;
     static maxAPY({ apy, leverage, baseRateWithFee, quotaRateWithFee, }: CalculateMaxAPYProps): number;
-    protected static maxLeverageThreshold(lpToken: string, cms: Array<PartialCM>): readonly [bigint, string];
+    protected static maxLeverageThreshold(lpToken: Address, cms: Array<PartialCM>): readonly [bigint, "" | `0x${string}`];
+    static isStrategyReleased(releaseAt: ReleaseAt, currentTimestamp: number, network: NetworkType): boolean;
 }
 type PartialCM = Pick<CreditManagerData, "liquidationThresholds" | "address">;
 export {};

package/lib/core/strategy.js

@@ -1,26 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Strategy = void 0;
+exports.PositionUtils = void 0;
 const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
-class Strategy {
-    apy;
-    name;
-    lpToken;
-    baseAssets;
-    unleveragableCollateral;
-    leveragableCollateral;
-    creditManagers;
-    constructor(payload) {
-        this.apy = payload.apy;
-        this.name = payload.name;
-        this.lpToken = payload.lpToken.toLowerCase();
-        this.creditManagers = payload.creditManagers.map(addr => addr.toLowerCase());
-        this.baseAssets = payload.baseAssets.map(addr => addr.toLowerCase());
-        this.unleveragableCollateral = payload.unleveragableCollateral.map(addr => addr.toLowerCase());
-        this.leveragableCollateral = payload.leveragableCollateral.map(addr => addr.toLowerCase());
-    }
+class PositionUtils {
     static maxLeverage(lpToken, cms) {
-        const [maxThreshold] = Strategy.maxLeverageThreshold(lpToken, cms);
+        const [maxThreshold] = this.maxLeverageThreshold(lpToken, cms);
         const maxLeverage = (sdk_gov_1.PERCENTAGE_FACTOR * sdk_gov_1.LEVERAGE_DECIMALS) /
             (sdk_gov_1.PERCENTAGE_FACTOR - maxThreshold);
         return Number(maxLeverage - sdk_gov_1.LEVERAGE_DECIMALS);
@@ -48,5 +32,15 @@ class Strategy {
         const [cm = "", lt = 0n] = sorted[0] || [];
         return [lt, cm];
     }
+    static isStrategyReleased(releaseAt, currentTimestamp, network) {
+        if (releaseAt === undefined)
+            return true;
+        if (typeof releaseAt === "number")
+            return currentTimestamp > releaseAt;
+        const releaseAtNetwork = releaseAt[network];
+        if (releaseAtNetwork === undefined)
+            return true;
+        return currentTimestamp > releaseAtNetwork;
+    }
 }
-exports.Strategy = Strategy;
+exports.PositionUtils = PositionUtils;