@gearbox-protocol/sdk 3.0.0-next.237 → 3.0.0-next.239

package/contracts/index.sol

@@ -72,6 +72,10 @@ import {ICurveV1_3AssetsAdapter} from
 import {ICurveV1_4AssetsAdapter} from
     "@gearbox-protocol/integrations-v3/contracts/interfaces/curve/ICurveV1_4AssetsAdapter.sol";
 
+import {IStakingRewardsAdapter} from
+    "@gearbox-protocol/integrations-v3/contracts/interfaces/sky/IStakingRewardsAdapter.sol";
+    
+
 
 import {IMulticall3} from "@gearbox-protocol/router-v3/lib/forge-std/src/interfaces/IMulticall3.sol";
 import {IRouterV3} from "@gearbox-protocol/router-v3/contracts/interfaces/IRouterV3.sol";

package/lib/apy/index.d.ts

@@ -9,7 +9,6 @@ export type TokensWithApyRecord = PartialRecord<TokensWithAPY, number>;
 export declare const isTokenWithAPY: (t: unknown) => t is TokensWithAPY;
 export type AllLPTokens = LPTokens | ExtraFarmTokens;
 export declare const isFarmToken: (t: unknown) => t is AllLPTokens;
-export * from "./convexAPY";
 export * from "./curveAPY";
 export * from "./defiLamaAPY";
 export * from "./lidoAPY";

package/lib/apy/index.js

@@ -83,7 +83,6 @@ const isFarmToken = (t) => {
     return (0, sdk_gov_1.isLPToken)(t) || (0, exports.isExtraFarmToken)(t);
 };
 exports.isFarmToken = isFarmToken;
-__exportStar(require("./convexAPY"), exports);
 __exportStar(require("./curveAPY"), exports);
 __exportStar(require("./defiLamaAPY"), exports);
 __exportStar(require("./lidoAPY"), exports);

package/lib/core/creditManager.d.ts

@@ -49,7 +49,11 @@ export declare class CreditManagerData {
     encodeDisableTokenV3(token: Address): MultiCall;
     encodeUpdateQuotaV3(token: Address, quotaChange: bigint, minQuota: bigint): MultiCall;
     encodeWithdrawCollateralV3(token: Address, amount: bigint, to: Address): MultiCall;
+    static withdrawAndUnwrap_Convex(address: Address, amount: bigint, claim: boolean): MultiCall;
     static withdrawAllAndUnwrap_Convex(address: Address, claim: boolean): MultiCall;
+    static withdrawAll_Rewards(address: Address): MultiCall;
+    static withdraw_Rewards(address: Address, amount: bigint): MultiCall;
+    static claim_Rewards(address: Address): MultiCall;
     encodeOnDemandPriceUpdateV3(token: Address, reserve: boolean, data: Address): MultiCall;
     static getTier(name: string): number;
     static getType(name: string): CreditManagerType;

package/lib/core/creditManager.js

@@ -211,6 +211,16 @@ class CreditManagerData {
             }),
         };
     }
+    static withdrawAndUnwrap_Convex(address, amount, claim) {
+        return {
+            target: address,
+            callData: (0, viem_1.encodeFunctionData)({
+                abi: types_1.iConvexV1BaseRewardPoolAdapterAbi,
+                functionName: "withdrawAndUnwrap",
+                args: [amount, claim],
+            }),
+        };
+    }
     static withdrawAllAndUnwrap_Convex(address, claim) {
         return {
             target: address,
@@ -221,6 +231,36 @@ class CreditManagerData {
             }),
         };
     }
+    static withdrawAll_Rewards(address) {
+        return {
+            target: address,
+            callData: (0, viem_1.encodeFunctionData)({
+                abi: types_1.iStakingRewardsAdapterAbi,
+                functionName: "withdrawDiff",
+                args: [1n],
+            }),
+        };
+    }
+    static withdraw_Rewards(address, amount) {
+        return {
+            target: address,
+            callData: (0, viem_1.encodeFunctionData)({
+                abi: types_1.iStakingRewardsAdapterAbi,
+                functionName: "withdraw",
+                args: [amount],
+            }),
+        };
+    }
+    static claim_Rewards(address) {
+        return {
+            target: address,
+            callData: (0, viem_1.encodeFunctionData)({
+                abi: types_1.iStakingRewardsAdapterAbi,
+                functionName: "getReward",
+                args: [],
+            }),
+        };
+    }
     encodeOnDemandPriceUpdateV3(token, reserve, data) {
         return {
             target: this.creditFacade,

package/lib/core/{rewardClaimer.d.ts → rewardClaimer/index.d.ts}

@@ -1,12 +1,11 @@
 import { NetworkType, PartialRecord, Protocols, SupportedContract, SupportedToken } from "@gearbox-protocol/sdk-gov";
 import { Address, PublicClient } from "viem";
-import { MultiCall } from "../pathfinder/core";
-import { CreditAccountData } from "./creditAccount";
-import { CreditManagerData } from "./creditManager";
+import { MultiCall } from "../../pathfinder/core";
+import { CreditAccountData } from "../creditAccount";
+import { CreditManagerData } from "../creditManager";
 export interface Rewards {
     contract: SupportedContract;
-    totalSupply: bigint;
-    protocol: Protocols.Aura | Protocols.Convex;
+    protocol: Protocols.Aura | Protocols.Convex | Protocols.Sky;
     rewards: PartialRecord<SupportedToken, bigint>;
     calls: Array<MultiCall>;
 }
@@ -17,4 +16,10 @@ export interface AdapterWithType {
 }
 export declare class RewardClaimer {
     static findRewards(ca: CreditAccountData, cm: CreditManagerData, network: NetworkType, provider: PublicClient): Promise<Array<Rewards>>;
+    static findRewardTokens(cm: CreditManagerData, provider: PublicClient): Promise<{
+        staking: {
+            adapters: AdapterWithType[];
+            tokens: (`0x${string}` | undefined)[];
+        };
+    }>;
 }

package/lib/core/rewardClaimer/index.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RewardClaimer = void 0;
+const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
+const rewardConvex_1 = require("./rewardConvex");
+const stakingRewards_1 = require("./stakingRewards");
+class RewardClaimer {
+    static async findRewards(ca, cm, network, provider) {
+        const tokens = await RewardClaimer.findRewardTokens(cm, provider);
+        const [convex, staking] = await Promise.all([
+            rewardConvex_1.RewardConvex.findRewards(ca, cm, network, provider),
+            stakingRewards_1.StakingRewards.findRewards(ca, provider, tokens.staking.adapters, tokens.staking.tokens),
+        ]);
+        return [...convex, ...staking];
+    }
+    static async findRewardTokens(cm, provider) {
+        const { calls: stakingCalls, adapters: stakingAdapters } = stakingRewards_1.StakingRewards.getRewardTokenCalls(cm);
+        const stakingTotal = stakingCalls.flat(1);
+        const response = await provider.multicall({
+            allowFailure: true,
+            multicallAddress: sdk_gov_1.MULTICALL_ADDRESS,
+            contracts: [...stakingTotal],
+        });
+        const stakingEnd = stakingTotal.length;
+        const stakingRewardTokensResponse = response.slice(0, stakingEnd);
+        return {
+            staking: {
+                adapters: stakingAdapters,
+                tokens: stakingRewardTokensResponse.map(r => r?.result),
+            },
+        };
+    }
+}
+exports.RewardClaimer = RewardClaimer;

package/lib/core/{rewardConvex.d.ts → rewardClaimer/rewardConvex.d.ts}

@@ -1,8 +1,8 @@
 import { NetworkType, Protocols, 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";
+import { CreditAccountData } from "../creditAccount";
+import { CreditManagerData } from "../creditManager";
+import { AdapterWithType, Rewards } from "../rewardClaimer";
 type DistributionList = Array<Array<RewardDistribution>>;
 type CallsList = Array<Array<{
     address: Address;

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

@@ -3,10 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RewardConvex = void 0;
 const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
 const viem_1 = require("viem");
-const apy_1 = require("../apy");
-const auraAbi_1 = require("../apy/auraAbi");
-const auraAPY_1 = require("../apy/auraAPY");
-const types_1 = require("../types");
+const types_1 = require("../../types");
+const aura_1 = require("./aura");
+const auraAbi_1 = require("./auraAbi");
+const convex_1 = require("./convex");
 // convex[totalSupply, ...tokens] aura[totalSupply, multiplier, ...tokens]
 class RewardConvex {
     static async findRewards(ca, cm, network, provider) {
@@ -198,7 +198,6 @@ class RewardConvex {
         // create base
         const base = {
             contract: baseDistribution.contract,
-            totalSupply: totalSupply,
             protocol: baseDistribution.protocol,
             rewards: {
                 [baseDistribution.token]: baseReward,
@@ -212,8 +211,8 @@ class RewardConvex {
         };
         // add boosted
         const boostedReward = baseDistribution.protocol === sdk_gov_1.Protocols.Aura
-            ? (0, auraAPY_1.getAURAMintAmount)(baseReward, totalSupply, multiplier)
-            : (0, apy_1.getCVXMintAmount)(baseReward, totalSupply);
+            ? (0, aura_1.getAURAMintAmount)(baseReward, totalSupply, multiplier)
+            : (0, convex_1.getCVXMintAmount)(baseReward, totalSupply);
         base.rewards = {
             ...base.rewards,
             [boostedRewardToken]: boostedReward,

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

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
 const chai_1 = require("chai");
 const viem_1 = require("viem");
-const types_1 = require("../types");
+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;
@@ -94,7 +94,6 @@ describe("RewardConvex test", () => {
         const expected = [
             {
                 protocol: sdk_gov_1.Protocols.Convex,
-                totalSupply: 0n,
                 contract: "CONVEX_3CRV_POOL",
                 rewards: {
                     CRV: 1000n,

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.addr, 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

@@ -18,7 +18,8 @@ interface CalculateMaxAPYProps {
 }
 export declare class Strategy {
     readonly name: string;
-    readonly lpTokenSymbol: AllLPTokens;
+    readonly id: AllLPTokens;
+    readonly tokenOut: AllLPTokens;
     readonly protocolSymbol: string;
     readonly releaseAt: ReleaseAt;
     readonly collateralTokens: Array<SupportedToken>;

package/lib/core/strategy.js

@@ -4,13 +4,15 @@ exports.Strategy = void 0;
 const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
 class Strategy {
     name;
-    lpTokenSymbol;
+    id;
+    tokenOut;
     protocolSymbol;
     releaseAt;
     collateralTokens;
     constructor(payload) {
         this.name = payload.name;
-        this.lpTokenSymbol = payload.lpTokenSymbol;
+        this.id = payload.lpTokenSymbol;
+        this.tokenOut = payload.lpTokenSymbol;
         this.protocolSymbol = payload.protocolSymbol;
         this.collateralTokens = payload.collateralTokens;
         this.releaseAt = payload.releaseAt;

package/lib/parsers/curveAdapterParser.js

@@ -9,7 +9,7 @@ class CurveAdapterParser extends abstractParser_1.AbstractParser {
     constructor(contract, isContract) {
         super(contract);
         let contractName = "";
-        const nCoins = sdk_gov_1.contractParams[contract].tokens.length;
+        const nCoins = sdk_gov_1.contractParams[contract]?.tokens?.length;
         switch (nCoins) {
             case 2:
                 this.abi = types_1.iCurveV1_2AssetsAdapterAbi;

package/lib/parsers/stakingRewardsAdapterParser.d.ts

@@ -0,0 +1,10 @@
+import { SupportedContract } from "@gearbox-protocol/sdk-gov";
+import { Address } from "viem";
+import { BigNumberish } from "../utils/formatter";
+import { AbstractParser } from "./abstractParser";
+import { IParser } from "./iParser";
+export declare class StakingRewardsAdapterParser extends AbstractParser implements IParser {
+    constructor(contract: SupportedContract, isContract: boolean);
+    parse(calldata: Address): string;
+    formatAmount(amount: BigNumberish): string;
+}

package/lib/parsers/stakingRewardsAdapterParser.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StakingRewardsAdapterParser = void 0;
+const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
+const types_1 = require("../types");
+const abstractParser_1 = require("./abstractParser");
+class StakingRewardsAdapterParser extends abstractParser_1.AbstractParser {
+    constructor(contract, isContract) {
+        super(contract);
+        this.abi = types_1.iStakingRewardsAdapterAbi;
+        if (!isContract)
+            this.adapterName = "StakingRewardsAdapter";
+    }
+    parse(calldata) {
+        const { functionName, functionData } = this.parseSelector(calldata);
+        switch (functionData.functionName) {
+            case "withdraw": {
+                const [amount] = functionData.args || [];
+                return `${functionName}(amount: ${this.formatAmount(amount)}`;
+            }
+            case "withdrawDiff": {
+                const [leftoverAmount] = functionData.args || [];
+                return `${functionName}(leftoverAmount: ${this.formatAmount(leftoverAmount)}`;
+            }
+            case "getReward":
+                return `${functionName}()`;
+            default:
+                return this.reportUnknownFragment(this.adapterName || this.contract, functionName, calldata);
+        }
+    }
+    formatAmount(amount) {
+        return this.formatBN(amount, sdk_gov_1.contractParams[this.contract].stakedToken);
+    }
+}
+exports.StakingRewardsAdapterParser = StakingRewardsAdapterParser;

package/lib/parsers/txParser.js

@@ -17,6 +17,7 @@ const erc626AdapterParser_1 = require("./erc626AdapterParser");
 const lidoAdapterParser_1 = require("./lidoAdapterParser");
 const lidoSTETHParser_1 = require("./lidoSTETHParser");
 const priceOracleParser_1 = require("./priceOracleParser");
+const stakingRewardsAdapterParser_1 = require("./stakingRewardsAdapterParser");
 const uniV2AdapterParser_1 = require("./uniV2AdapterParser");
 const uniV3AdapterParser_1 = require("./uniV3AdapterParser");
 const wstETHAdapterParser_1 = require("./wstETHAdapterParser");
@@ -131,6 +132,9 @@ class TxParser {
             case "YEARN_V2":
                 TxParser._addParser(addressLC, new yearnV2AdapterParser_1.YearnV2AdapterParser(contract, isContract));
                 break;
+            case "STAKING_REWARDS":
+                TxParser._addParser(addressLC, new stakingRewardsAdapterParser_1.StakingRewardsAdapterParser(contract, isContract));
+                break;
             case "CONVEX_V1_BASE_REWARD_POOL":
                 TxParser._addParser(addressLC, new convexBaseRewardPoolAdapterParser_1.ConvexBaseRewardPoolAdapterParser(contract, isContract));
                 break;

package/lib/redstone/api.d.ts

@@ -29,11 +29,6 @@ export declare class RedstoneApi {
     }>;
     private static getDataPackages;
     private static splitResponse;
-    static getRedstonePriceFeedsSDK: ({ priceOracleAddress, currentTokenData, provider, network, }: GetRedstoneFeedsProps) => Promise<{
-        main: RedstonePriceFeeds;
-        reserve: RedstonePriceFeeds;
-    }>;
-    private static getRedstonePF_SDK;
     static getRedstonePriceFeeds: ({ priceOracleAddress, currentTokenData, provider, network, }: GetRedstoneFeedsProps) => Promise<{
         main: RedstonePriceFeeds;
         reserve: RedstonePriceFeeds;