@gearbox-protocol/sdk 3.0.0-next.18 → 3.0.0-next.181

package/lib/core/rewardClaimer.d.ts

@@ -1,11 +1,13 @@
-import { NetworkType, SupportedContract, SupportedToken } from "@gearbox-protocol/sdk-gov";
-import { providers } from "ethers";
+import { NetworkType, PartialRecord, Protocols, SupportedContract, SupportedToken } from "@gearbox-protocol/sdk-gov";
+import { Provider } from "ethers";
 import { MultiCall } from "../pathfinder/core";
 import { CreditAccountData } from "./creditAccount";
 import { CreditManagerData } from "./creditManager";
 export interface Rewards {
     contract: SupportedContract;
-    rewards: Partial<Record<SupportedToken, bigint>>;
+    totalSupply: bigint;
+    protocol: Protocols.Aura | Protocols.Convex;
+    rewards: PartialRecord<SupportedToken, bigint>;
     calls: Array<MultiCall>;
 }
 export interface AdapterWithType {
@@ -14,5 +16,5 @@ export interface AdapterWithType {
     contract: SupportedContract;
 }
 export declare class RewardClaimer {
-    static findRewards(ca: CreditAccountData, cm: CreditManagerData, network: NetworkType, provider: providers.Provider): Promise<Array<Rewards>>;
+    static findRewards(ca: CreditAccountData, cm: CreditManagerData, network: NetworkType, provider: Provider): Promise<Array<Rewards>>;
 }

package/lib/core/rewardConvex.d.ts

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

package/lib/core/rewardConvex.js

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

package/lib/core/rewardConvex.spec.js

@@ -2,7 +2,7 @@
 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 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 +23,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 +36,21 @@ 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,
+                    interface: types_1.IConvexToken__factory.createInterface(),
+                    method: "totalSupply()",
+                },
+            ],
+            [
+                {
+                    address: sdk_gov_1.contractsByNetwork.Mainnet.CONVEX_3CRV_POOL,
+                    interface: rewardConvex_1.RewardConvex.poolInterface,
+                    method: "earned(address)",
+                    params: [CREDIT_ACCOUNT],
+                },
+            ],
         ];
         const distribution = [
             {
@@ -67,56 +58,41 @@ 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 parsed = rewardConvex_1.RewardConvex.parseResults({
+            convexDistribution: [distribution],
+            convexResponse: rewards,
+            convexTotalSupply: 0n,
+            auraDistribution: [],
+            auraResponse: [],
+            auraTotalSupply: 0n,
+        });
         const callData = rewardConvex_1.RewardConvex.poolInterface.encodeFunctionData("getReward()");
         const expected = [
             {
+                protocol: sdk_gov_1.Protocols.Convex,
+                totalSupply: 0n,
                 contract: "CONVEX_3CRV_POOL",
                 rewards: {
                     CRV: 1000n,
+                    CVX: 1000n,
                 },
                 calls: [
                     {
@@ -125,19 +101,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/strategy.d.ts

@@ -1,33 +1,30 @@
+import { SupportedToken } from "@gearbox-protocol/sdk-gov";
+import { TokensWithAPY } from "../apy";
 import { CreditManagerData } from "./creditManager";
 export interface StrategyPayload {
-    apy?: number;
     name: string;
-    lpToken: string;
+    lpTokenSymbol: TokensWithAPY;
+    protocolSymbol: string;
     creditManagers: Array<string>;
-    baseAssets: Array<string>;
-    unleveragableCollateral: Array<string>;
-    leveragableCollateral: Array<string>;
+    collateralTokens: Array<SupportedToken>;
+    liquidationTokens: Array<SupportedToken>;
 }
-interface LiquidationPriceProps {
-    prices: Record<string, bigint>;
-    liquidationThresholds: Record<string, bigint>;
-    borrowed: bigint;
-    underlyingToken: string;
-    lpAmount: bigint;
-    lpToken: string;
+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>;
+    readonly name: string;
+    readonly lpTokenSymbol: TokensWithAPY;
+    readonly protocolSymbol: string;
+    readonly collateralTokens: Array<SupportedToken>;
+    readonly liquidationTokens: Array<SupportedToken>;
+    readonly creditManagers: Array<string>;
     constructor(payload: StrategyPayload);
     static maxLeverage(lpToken: string, cms: Array<PartialCM>): number;
-    maxAPY(baseAPY: number, maxLeverage: number, borrowAPY: number): number;
-    static liquidationPrice({ prices, liquidationThresholds, borrowed, underlyingToken, lpAmount, lpToken, }: LiquidationPriceProps): bigint;
+    static maxAPY({ apy, leverage, baseRateWithFee, quotaRateWithFee, }: CalculateMaxAPYProps): number;
     protected static maxLeverageThreshold(lpToken: string, cms: Array<PartialCM>): readonly [bigint, string];
 }
 type PartialCM = Pick<CreditManagerData, "liquidationThresholds" | "address">;

package/lib/core/strategy.js

@@ -2,23 +2,20 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Strategy = void 0;
 const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
-const price_1 = require("../utils/price");
 class Strategy {
-    apy;
     name;
-    lpToken;
-    baseAssets;
-    unleveragableCollateral;
-    leveragableCollateral;
+    lpTokenSymbol;
+    protocolSymbol;
+    collateralTokens;
+    liquidationTokens;
     creditManagers;
     constructor(payload) {
-        this.apy = payload.apy;
         this.name = payload.name;
-        this.lpToken = payload.lpToken.toLowerCase();
+        this.lpTokenSymbol = payload.lpTokenSymbol;
+        this.protocolSymbol = payload.protocolSymbol;
         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());
+        this.collateralTokens = payload.collateralTokens;
+        this.liquidationTokens = payload.liquidationTokens;
     }
     static maxLeverage(lpToken, cms) {
         const [maxThreshold] = Strategy.maxLeverageThreshold(lpToken, cms);
@@ -26,29 +23,12 @@ class Strategy {
             (sdk_gov_1.PERCENTAGE_FACTOR - maxThreshold);
         return Number(maxLeverage - sdk_gov_1.LEVERAGE_DECIMALS);
     }
-    maxAPY(baseAPY, maxLeverage, borrowAPY) {
-        return (baseAPY +
-            ((baseAPY - borrowAPY) * (maxLeverage - Number(sdk_gov_1.LEVERAGE_DECIMALS))) /
-                Number(sdk_gov_1.LEVERAGE_DECIMALS));
-    }
-    static liquidationPrice({ prices, liquidationThresholds, borrowed, underlyingToken, lpAmount, lpToken, }) {
-        const underlyingTokenAddressLC = underlyingToken.toLowerCase();
-        const underlyingTokenSymbol = sdk_gov_1.tokenSymbolByAddress[underlyingTokenAddressLC];
-        const underlyingTokenDecimals = sdk_gov_1.decimals[underlyingTokenSymbol];
-        const underlyingPrice = prices[underlyingTokenAddressLC] || sdk_gov_1.PRICE_DECIMALS;
-        const borrowedMoney = price_1.PriceUtils.calcTotalPrice(underlyingPrice, borrowed, underlyingTokenDecimals);
-        const lpTokenAddressLC = lpToken.toLowerCase();
-        const lpTokenSymbol = sdk_gov_1.tokenSymbolByAddress[lpTokenAddressLC];
-        const lpTokenDecimals = sdk_gov_1.decimals[lpTokenSymbol];
-        const lpLT = liquidationThresholds[lpTokenAddressLC] || 0n;
-        const lpPrice = prices[lpTokenAddressLC] || sdk_gov_1.PRICE_DECIMALS;
-        const lpMoney = price_1.PriceUtils.calcTotalPrice(lpPrice, lpAmount, lpTokenDecimals);
-        const lpLTMoney = (lpMoney * lpLT) / sdk_gov_1.PERCENTAGE_FACTOR;
-        if (lpLTMoney > 0) {
-            const lqPrice = (borrowedMoney * sdk_gov_1.WAD) / lpLTMoney;
-            return lqPrice >= 0 ? lqPrice : 0n;
-        }
-        return 0n;
+    static maxAPY({ apy, leverage, baseRateWithFee, quotaRateWithFee, }) {
+        const collateralTerm = apy - quotaRateWithFee;
+        const debtTerm = ((apy - baseRateWithFee - quotaRateWithFee) *
+            (leverage - Number(sdk_gov_1.LEVERAGE_DECIMALS))) /
+            Number(sdk_gov_1.LEVERAGE_DECIMALS);
+        return collateralTerm + Math.floor(debtTerm);
     }
     static maxLeverageThreshold(lpToken, cms) {
         const lpTokenLC = lpToken.toLowerCase();