@gearbox-protocol/sdk 0.0.99 → 0.0.102

package/lib/payload/creditAccount.d.ts

@@ -1,26 +1,4 @@
-import { BigNumberish } from "ethers";
-export interface TokenBalancePayload {
-    token: string;
-    balance: BigNumberish;
-    isAllowed: boolean;
-}
-export interface CreditAccountDataPayload {
-    addr: string;
-    borrower: string;
-    inUse: boolean;
-    creditManager: string;
-    underlyingToken: string;
-    borrowedAmountPlusInterest: BigNumberish;
-    totalValue: BigNumberish;
-    healthFactor: BigNumberish;
-    borrowRate: BigNumberish;
-    balances?: Array<TokenBalancePayload>;
-}
-export interface CreditAccountDataExtendedPayload extends CreditAccountDataPayload {
-    repayAmount: BigNumberish;
-    liquidationAmount: BigNumberish;
-    canBeClosed?: boolean;
-    borrowedAmount: BigNumberish;
-    cumulativeIndexAtOpen: BigNumberish;
-    since: BigNumberish;
-}
+import { CreditAccountDataStruct } from "../types/contracts/core/DataCompressor";
+export declare type TokenBalancePayload = CreditAccountDataStruct["balances"];
+export declare type CreditAccountDataPayload = CreditAccountDataStruct;
+export declare type CreditAccountDataExtendedPayload = CreditAccountDataStruct;

package/lib/payload/creditManager.d.ts

@@ -1,33 +1,11 @@
 import { BigNumberish } from "ethers";
+import { CreditManagerDataStruct } from "../types/contracts/interfaces/IDataCompressor.sol/IDataCompressor";
 export interface AdapterPayload {
     allowedContract: string;
     adapter: string;
 }
-export interface CreditManagerDataPayload {
-    addr: string;
-    hasAccount?: boolean;
-    underlyingToken?: string;
-    isWETH?: boolean;
-    canBorrow?: boolean;
-    borrowRate?: BigNumberish;
-    minAmount?: BigNumberish;
-    maxAmount?: BigNumberish;
-    maxLeverageFactor?: BigNumberish;
-    availableLiquidity?: BigNumberish;
-    allowedTokens?: Array<string>;
-    adapters?: Array<AdapterPayload>;
-}
-export interface CreditManagerStatPayload {
-    addr: string;
-    underlyingToken?: string;
-    isWETH?: boolean;
-    canBorrow?: boolean;
-    borrowRate?: BigNumberish;
-    minAmount?: BigNumberish;
-    maxAmount?: BigNumberish;
-    maxLeverageFactor?: BigNumberish;
-    availableLiquidity?: BigNumberish;
-    allowedTokens?: Array<string>;
+export declare type CreditManagerDataPayload = CreditManagerDataStruct;
+export interface CreditManagerStatPayload extends CreditManagerDataPayload {
     allowedContracts?: Array<string>;
     uniqueUsers: number;
     openedAccountsCount?: number;

package/lib/payload/pool.d.ts

@@ -1,17 +1,2 @@
-import { BigNumberish } from "ethers";
-export interface PoolDataPayload {
-    addr: string;
-    underlyingToken: string;
-    dieselToken: string;
-    isWETH: boolean;
-    expectedLiquidity: BigNumberish;
-    expectedLiquidityLimit?: BigNumberish;
-    availableLiquidity: BigNumberish;
-    totalBorrowed: BigNumberish;
-    depositAPY_RAY: BigNumberish;
-    borrowAPY_RAY: BigNumberish;
-    dieselRate_RAY: BigNumberish;
-    withdrawFee: BigNumberish;
-    timestampLU?: BigNumberish;
-    cumulativeIndex_RAY?: BigNumberish;
-}
+import { PoolDataStruct } from "../types/contracts/interfaces/IDataCompressor.sol/IDataCompressor";
+export declare type PoolDataPayload = PoolDataStruct;

package/lib/payload/pool.js

@@ -1,3 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//

package/lib/tokens/token.js

@@ -141,24 +141,24 @@ exports.tokenDataByNetwork = {
         cvxsteCRV: "0xb22c2015327cfbeD480eF45B6382d4bC963a4595",
         cvxcrvPlain3andSUSD: "0xBBeAdEA3C648cF4026d0422EAF2463050202700b",
         cvxFRAX3CRV: "0xBC523005975D86de9226785DD83e4f8d2A87fA73",
-        cvxLUSD3CRV: "0xF1128521595A6CAee02af9DBdb15857954cC2cA0",
+        cvxLUSD3CRV: "0xF90d9a96985a80e6c2cA9952cd2C6Db5B720408F",
         cvxgusd3CRV: "0xa3aDFDf18d166e26bF1Bc0ee63D26d0d1064b056",
         // CONVEX PHANTOM TOKEN ADDRESSES
         stkcvx3Crv: "0xf4FC4Aa052346fEa87f1e864f10de0f7383e9502",
         stkcvxFRAX3CRV: "0xd726f9684245065B120E1ac18de389f6b05351Ba",
-        stkcvxLUSD3CRV: "0x028b65EE7B3B70307d653Ed9cC93ae30e05e4026",
+        stkcvxLUSD3CRV: "0x5c355c46413B45Cc58aB61AcaF5BB72E7c2d1465",
         stkcvxgusd3CRV: "0x9A74e8106f6c28b21b1B6a0F985cf1227BE05F04",
         stkcvxsteCRV: "0xd8bAbB7EfBF7F931a69B209f71b27421F8b18516",
         stkcvxcrvPlain3andSUSD: "0x6b45Cab756B41a7204973b71362ef5F73E67F6DA",
         //GEARBOX
-        dDAI: "0x0d06D2e31781A0585feE334F63beF43543496e5d",
-        dUSDC: "0xcCc83353856A79c94EaDa39Df76B9c7C4c762dBF",
-        dWBTC: "0x4cCb374472C8c73b067c8c40b9420a221Ef014ca",
-        dWETH: "0x3B1e0Db6C960b32beEDf82af9db2da63F15Ba01E",
+        dDAI: "0x077a3Ce0D572b72436F6644793Fc7721353aF1f4",
+        dUSDC: "0x8147e00456c8A3128182730bFFdFd9D1E6bbC048",
+        dWBTC: "0x34D9B3c13B25632879B2DaabBde702F612902238",
+        dWETH: "0x19e4F905749D3b487CA4927b54e55b64625a1143",
         GEAR: "0xe01c5d0297c56e992dab3886057a1441485ff7c7"
     }
 };
-exports.tokenSymbolByAddress = (0, mappers_1.objectEntries)(exports.tokenDataByNetwork).reduce(function (sum, _a) {
+exports.tokenSymbolByAddress = (0, mappers_1.objectEntries)(exports.tokenDataByNetwork).reduce(function (acc, _a) {
     var _ = _a[0], tokens = _a[1];
-    return __assign(__assign({}, sum), (0, mappers_1.keyToLowercase)((0, mappers_1.swapKeyValue)(tokens)));
+    return __assign(__assign({}, acc), (0, mappers_1.filterEmptyKeys)((0, mappers_1.keyToLowercase)((0, mappers_1.swapKeyValue)(tokens))));
 }, {});

package/lib/utils/formatter.d.ts

@@ -11,3 +11,4 @@ export declare function shortHash(address?: string): string;
 export declare const formatRate: (rate: BigNumberish | undefined) => string;
 export declare function formatDate(date: Date): string;
 export declare function formatHf(healthFactor: number): string;
+export declare function formatLeverage(leverage: number, decimals?: number): string;

package/lib/utils/formatter.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.formatHf = exports.formatDate = exports.formatRate = exports.shortHash = exports.shortAddress = exports.toBN = exports.toSignificant = exports.toHumanFormat = exports.formatBn4dig = exports.formatBN = exports.formatRAY = exports.rayToNumber = void 0;
+exports.formatLeverage = exports.formatHf = exports.formatDate = exports.formatRate = exports.shortHash = exports.shortAddress = exports.toBN = exports.toSignificant = exports.toHumanFormat = exports.formatBn4dig = exports.formatBN = exports.formatRAY = exports.rayToNumber = void 0;
 var ethers_1 = require("ethers");
 var constants_1 = require("../core/constants");
 var decimal_js_light_1 = __importDefault(require("decimal.js-light"));
@@ -123,3 +123,8 @@ function formatHf(healthFactor) {
     return (healthFactor / 10000).toFixed(2);
 }
 exports.formatHf = formatHf;
+function formatLeverage(leverage, decimals) {
+    if (decimals === void 0) { decimals = 2; }
+    return (leverage / constants_1.LEVERAGE_DECIMALS).toFixed(decimals);
+}
+exports.formatLeverage = formatLeverage;

package/lib/utils/mappers.d.ts

@@ -2,5 +2,6 @@ declare type SupportedValue = string | number;
 declare const objectEntries: <K extends SupportedValue, T>(o: Record<K, T>) => [K, T][];
 declare const swapKeyValue: <K extends SupportedValue, T extends SupportedValue>(o: Record<K, T>) => Record<T, K>;
 declare const keyToLowercase: <K extends SupportedValue, T extends SupportedValue>(o: Record<K, T>) => Record<K, T>;
+declare const filterEmptyKeys: <K extends SupportedValue, T extends SupportedValue>(o: Record<K, T>) => Record<K, T>;
 export type { SupportedValue };
-export { objectEntries, swapKeyValue, keyToLowercase };
+export { objectEntries, swapKeyValue, keyToLowercase, filterEmptyKeys };

package/lib/utils/mappers.js

@@ -11,23 +11,31 @@ var __assign = (this && this.__assign) || function () {
     return __assign.apply(this, arguments);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.keyToLowercase = exports.swapKeyValue = exports.objectEntries = void 0;
+exports.filterEmptyKeys = exports.keyToLowercase = exports.swapKeyValue = exports.objectEntries = void 0;
 var objectEntries = function (o) { return Object.entries(o); };
 exports.objectEntries = objectEntries;
 var swapKeyValue = function (o) {
-    return objectEntries(o).reduce(function (sum, _a) {
+    return objectEntries(o).reduce(function (acc, _a) {
         var _b;
         var key = _a[0], value = _a[1];
-        return __assign(__assign({}, sum), (_b = {}, _b[value] = key, _b));
+        return __assign(__assign({}, acc), (_b = {}, _b[value] = key, _b));
     }, {});
 };
 exports.swapKeyValue = swapKeyValue;
 var keyToLowercase = function (o) {
-    return objectEntries(o).reduce(function (sum, _a) {
+    return objectEntries(o).reduce(function (acc, _a) {
         var _b;
         var key = _a[0], value = _a[1];
         var keyTransformed = typeof key === "string" ? key.toLowerCase() : key;
-        return __assign(__assign({}, sum), (_b = {}, _b[keyTransformed] = value, _b));
+        return __assign(__assign({}, acc), (_b = {}, _b[keyTransformed] = value, _b));
     }, {});
 };
 exports.keyToLowercase = keyToLowercase;
+var filterEmptyKeys = function (o) {
+    return objectEntries(o).reduce(function (acc, _a) {
+        var _b;
+        var key = _a[0], value = _a[1];
+        return !!key ? __assign(__assign({}, acc), (_b = {}, _b[key] = value, _b)) : acc;
+    }, {});
+};
+exports.filterEmptyKeys = filterEmptyKeys;

package/lib/utils/multicall.js

@@ -37,6 +37,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MultiCallContract = exports.multicall = void 0;
+var config_1 = require("../config");
 var types_1 = require("../types");
 function multicall(calls, p) {
     return __awaiter(this, void 0, void 0, function () {
@@ -44,7 +45,7 @@ function multicall(calls, p) {
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
-                    multiCallContract = types_1.Multicall2__factory.connect("0x5ba1e12693dc8f9c48aad8770482f4739beed696", p);
+                    multiCallContract = types_1.Multicall2__factory.connect(config_1.MULTICALL_ADDRESS, p);
                     return [4 /*yield*/, multiCallContract.callStatic.aggregate(calls.map(function (c) { return ({
                             target: c.address,
                             callData: c.interface.encodeFunctionData(c.method, c.params)
@@ -55,7 +56,7 @@ function multicall(calls, p) {
                             .map(function (d, num) {
                             return calls[num].interface.decodeFunctionResult(calls[num].method, d);
                         })
-                            .map(function (r) { return r[0]; })];
+                            .map(function (r) { return (Array.isArray(r) && r.length <= 1 ? r[0] : r); })];
             }
         });
     });
@@ -65,7 +66,7 @@ var MultiCallContract = /** @class */ (function () {
     function MultiCallContract(address, intrerface, provider) {
         this._address = address;
         this._interface = intrerface;
-        this._multiCall = types_1.Multicall2__factory.connect("0x5ba1e12693dc8f9c48aad8770482f4739beed696", provider);
+        this._multiCall = types_1.Multicall2__factory.connect(config_1.MULTICALL_ADDRESS, provider);
     }
     MultiCallContract.prototype.call = function (data) {
         return __awaiter(this, void 0, void 0, function () {

package/lib/utils/types.d.ts

@@ -1,3 +1,4 @@
 export declare type PartialRecord<K extends keyof any, T> = {
     [P in K]?: T;
 };
+export declare type AwaitedRes<T extends (...args: any) => any> = Awaited<ReturnType<T>>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gearbox-protocol/sdk",
-  "version": "0.0.99",
+  "version": "0.0.102",
   "description": "Gearbox SDK",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",

package/src/apy/convexAPY.ts

@@ -0,0 +1,250 @@
+import { BigNumber, providers } from "ethers";
+import axios from "axios";
+import {
+  ConvexPoolContract,
+  ConvexPoolParams,
+  contractsByNetwork,
+  contractParams,
+  CurvePoolContract
+} from "../contracts/contracts";
+
+import { tokenDataByNetwork, supportedTokens } from "../tokens/token";
+import { CurveLPToken } from "../tokens/curveLP";
+import { ConvexPhantomTokenData } from "../tokens/convex";
+
+import {
+  IBaseRewardPool__factory,
+  IBaseRewardPool,
+  IConvexToken__factory,
+  IConvexToken,
+  CurveV1AdapterStETH,
+  CurveV1AdapterStETH__factory
+} from "../types";
+
+import { multicall, MCall } from "../utils/multicall";
+import { toBN } from "../utils/formatter";
+import { AwaitedRes } from "../utils/types";
+
+import {
+  SECONDS_PER_YEAR,
+  WAD,
+  WAD_DECIMALS_POW,
+  NetworkType,
+  PRICE_DECIMALS
+} from "../core/constants";
+
+type SupportedPools = Extract<
+  ConvexPoolContract,
+  | "CONVEX_3CRV_POOL"
+  | "CONVEX_FRAX3CRV_POOL"
+  | "CONVEX_LUSD3CRV_POOL"
+  | "CONVEX_GUSD_POOL"
+  | "CONVEX_SUSD_POOL"
+>;
+
+type SupportedConvex = Extract<
+  CurvePoolContract,
+  | "CURVE_3CRV_POOL"
+  | "CURVE_FRAX_POOL"
+  | "CURVE_LUSD_POOL"
+  | "CURVE_GUSD_POOL"
+  | "CURVE_SUSD_POOL"
+>;
+
+const curveSwapByPool: Record<SupportedPools, SupportedConvex> = {
+  CONVEX_3CRV_POOL: "CURVE_3CRV_POOL",
+  CONVEX_FRAX3CRV_POOL: "CURVE_FRAX_POOL",
+  CONVEX_LUSD3CRV_POOL: "CURVE_LUSD_POOL",
+  CONVEX_GUSD_POOL: "CURVE_GUSD_POOL",
+  CONVEX_SUSD_POOL: "CURVE_SUSD_POOL"
+};
+
+export async function getConvexApy(
+  pool: SupportedPools,
+  provider: providers.Provider,
+  networkType: NetworkType,
+  getTokenPrice: (tokenAddress: string) => BigNumber
+) {
+  const tokenList = tokenDataByNetwork[networkType];
+  const contractsList = contractsByNetwork[networkType];
+
+  const poolParams = contractParams[pool] as ConvexPoolParams;
+  const stakedTokenParams = supportedTokens[
+    poolParams.stakedToken
+  ] as ConvexPhantomTokenData;
+
+  const underlying = stakedTokenParams.underlying;
+  const basePoolAddress = contractsList[pool];
+  const swapPoolAddress = contractsList[curveSwapByPool[pool]];
+  const cvxAddress = tokenList.CVX;
+
+  const extraPoolAddresses = poolParams.extraRewards.map(d => {
+    return d.poolAddress[networkType];
+  });
+
+  const [basePoolRate, basePoolSupply, vPrice, cvxSupply, ...extra] =
+    await getPoolData(
+      basePoolAddress,
+      swapPoolAddress,
+      cvxAddress,
+      extraPoolAddresses,
+      provider
+    );
+
+  const cvxPrice = getTokenPrice(tokenList["CVX"]);
+  const crvPrice = getTokenPrice(tokenList["CRV"]);
+
+  const crvPerSecond = basePoolRate;
+  const virtualSupply = basePoolSupply.mul(vPrice).div(WAD);
+  const crvPerUnderlying = crvPerSecond.mul(WAD).div(virtualSupply);
+
+  const crvPerYear = crvPerUnderlying.mul(SECONDS_PER_YEAR);
+  const cvxPerYear = getCVXMintAmount(crvPerYear, cvxSupply);
+
+  const crvAPY = crvPerYear.mul(cvxPrice).div(PRICE_DECIMALS);
+  const cvxAPY = cvxPerYear.mul(crvPrice).div(PRICE_DECIMALS);
+
+  const extraAPRs = await Promise.all(
+    extraPoolAddresses.map(async (_, index) => {
+      const extraRewardSymbol = poolParams.extraRewards[index].rewardToken;
+      const extraPoolRate = extra[index];
+
+      const perUnderlying = extraPoolRate.mul(WAD).div(virtualSupply);
+      const perYear = perUnderlying.mul(SECONDS_PER_YEAR);
+
+      const extraPrise = getTokenPrice(tokenList[extraRewardSymbol]);
+
+      const extraAPY = perYear.mul(extraPrise).div(PRICE_DECIMALS);
+
+      return extraAPY;
+    })
+  );
+
+  const extraAPYTotal = extraAPRs.reduce(
+    (acc, apy) => acc.add(apy),
+    BigNumber.from(0)
+  );
+
+  const baseApyRAY = await getCurveBaseApy(underlying);
+
+  return baseApyRAY.add(crvAPY).add(cvxAPY).add(extraAPYTotal);
+}
+
+const CVX_MAX_SUPPLY = WAD.mul(100000000);
+const CVX_REDUCTION_PER_CLIFF = BigNumber.from(100000);
+const CVX_TOTAL_CLIFFS = WAD.mul(1000);
+
+function getCVXMintAmount(crvAmount: BigNumber, cvxSupply: BigNumber) {
+  const currentCliff = cvxSupply.div(CVX_REDUCTION_PER_CLIFF);
+
+  if (currentCliff.lt(CVX_TOTAL_CLIFFS)) {
+    const remainingCliffs = CVX_TOTAL_CLIFFS.sub(currentCliff);
+
+    const mintedAmount = crvAmount.mul(remainingCliffs).div(CVX_TOTAL_CLIFFS);
+
+    const amountTillMax = CVX_MAX_SUPPLY.sub(cvxSupply);
+
+    return mintedAmount.gt(amountTillMax) ? amountTillMax : mintedAmount;
+  }
+
+  return BigNumber.from(0);
+}
+
+type IBaseRewardPoolInterface = IBaseRewardPool["interface"];
+type IConvexTokenInterface = IConvexToken["interface"];
+type CurveV1AdapterStETHInterface = CurveV1AdapterStETH["interface"];
+
+async function getPoolData(
+  basePoolAddress: string,
+  underlying: string,
+  cvxAddress: string,
+  extraPoolAddresses: string[],
+  provider: providers.Provider
+) {
+  const calls: [
+    MCall<IBaseRewardPoolInterface>,
+    MCall<IBaseRewardPoolInterface>,
+    MCall<CurveV1AdapterStETHInterface>,
+    MCall<IConvexTokenInterface>,
+    ...Array<MCall<IBaseRewardPoolInterface>>
+  ] = [
+    {
+      address: basePoolAddress,
+      interface: IBaseRewardPool__factory.createInterface(),
+      method: "rewardRate()"
+    },
+    {
+      address: basePoolAddress,
+      interface: IBaseRewardPool__factory.createInterface(),
+      method: "totalSupply()"
+    },
+    {
+      address: underlying,
+      interface: CurveV1AdapterStETH__factory.createInterface(),
+      method: "get_virtual_price()"
+    },
+    {
+      address: cvxAddress,
+      interface: IConvexToken__factory.createInterface(),
+      method: "totalSupply()"
+    },
+    ...extraPoolAddresses.map(
+      (extraPoolAddress): MCall<IBaseRewardPoolInterface> => ({
+        address: extraPoolAddress,
+        interface: IBaseRewardPool__factory.createInterface(),
+        method: "rewardRate()"
+      })
+    )
+  ];
+
+  return multicall<
+    [
+      AwaitedRes<IBaseRewardPool["rewardRate"]>,
+      AwaitedRes<IBaseRewardPool["totalSupply"]>,
+      AwaitedRes<CurveV1AdapterStETH["get_virtual_price"]>,
+      AwaitedRes<IConvexToken["totalSupply"]>,
+      ...Array<AwaitedRes<IBaseRewardPool["rewardRate"]>>
+    ]
+  >(calls, provider);
+}
+
+interface CurveAPRData {
+  baseApy: number;
+  crvApy: number;
+  crvBoost: number;
+  crvPrice: number;
+}
+
+interface APYResponse {
+  apys: Record<string, CurveAPRData>;
+}
+
+const curveLPTokenToPoolName: Record<CurveLPToken, string> = {
+  "3Crv": "3pool",
+  FRAX3CRV: "frax",
+  gusd3CRV: "gusd",
+  LUSD3CRV: "lusd",
+  crvPlain3andSUSD: "susdv2",
+  steCRV: "steth"
+};
+
+const RESPONSE_DECIMALS = 100;
+
+// https://www.convexfinance.com/api/curve-apys
+
+export async function getCurveBaseApy(
+  curveLPToken: CurveLPToken
+): Promise<BigNumber> {
+  const poolName = curveLPTokenToPoolName[curveLPToken];
+
+  try {
+    const url = "https://www.convexfinance.com/api/curve-apys";
+    const result = await axios.get<APYResponse>(url);
+
+    const { baseApy = 0 } = result.data.apys[poolName] || {};
+
+    return toBN((baseApy / RESPONSE_DECIMALS).toString(), WAD_DECIMALS_POW);
+  } catch (e) {
+    return BigNumber.from(0);
+  }
+}

package/src/apy/lidoAPY.ts

@@ -0,0 +1,88 @@
+import { providers } from "ethers";
+
+import { multicall, MCall } from "../utils/multicall";
+import { contractParams, LidoParams } from "../contracts/contracts";
+import { tokenDataByNetwork } from "../tokens/token";
+
+import { WAD, SECONDS_PER_YEAR, NetworkType } from "../core/constants";
+
+import {
+  ILidoOracle__factory,
+  ILidoOracle,
+  IstETH__factory,
+  IstETH
+} from "../types";
+
+type ILidoOracleInterface = ILidoOracle["interface"];
+
+type IstETHInterface = IstETH["interface"];
+
+const lidoOracleAddress = (contractParams.LIDO_STETH_GATEWAY as LidoParams)
+  .oracle;
+
+const lidoStEthAddress: Record<NetworkType, string> = {
+  Mainnet: tokenDataByNetwork.Mainnet.STETH,
+  Kovan: tokenDataByNetwork.Kovan.STETH
+};
+
+export async function getLidoApy(
+  provider: providers.Provider,
+  networkType: NetworkType
+) {
+  if (!lidoOracleAddress[networkType]) {
+    throw `No Lido APR oracle found on current network: ${networkType}`;
+  }
+  if (!lidoStEthAddress[networkType]) {
+    throw `No Lido stETH found on current network: ${networkType}`;
+  }
+
+  const [{ postTotalPooledEther, preTotalPooledEther, timeElapsed }, fee] =
+    await geLidoData(
+      lidoOracleAddress[networkType],
+      lidoStEthAddress[networkType],
+      provider,
+      networkType
+    );
+
+  const lidoAPRRay = postTotalPooledEther
+    .sub(preTotalPooledEther)
+    .mul(SECONDS_PER_YEAR)
+    .mul(WAD)
+    .div(preTotalPooledEther.mul(timeElapsed));
+
+  return [lidoAPRRay, fee] as const;
+}
+
+async function geLidoData(
+  lidoOracleAddress: string,
+  stETHAddress: string,
+  provider: providers.Provider,
+  network: NetworkType
+) {
+  const calls: [MCall<ILidoOracleInterface>, ...Array<MCall<IstETHInterface>>] =
+    [
+      {
+        address: lidoOracleAddress,
+        interface: ILidoOracle__factory.createInterface(),
+        method: "getLastCompletedReportDelta()"
+      }
+    ];
+
+  if (network !== "Kovan")
+    calls.push({
+      address: stETHAddress,
+      interface: IstETH__factory.createInterface(),
+      method: "getFee()"
+    });
+
+  const [stats, fee = Math.floor(LIDO_FEE_DECIMALS / 10)] = await multicall<
+    [
+      Awaited<ReturnType<ILidoOracle["getLastCompletedReportDelta"]>>,
+      Awaited<ReturnType<IstETH["getFee"]>>
+    ]
+  >(calls, provider);
+
+  return [stats, fee] as const;
+}
+
+export const LIDO_FEE_DECIMALS = 10000;

package/src/config.ts

@@ -1 +1,2 @@
-export const STATIC_TOKEN = "https://static.gearbox.fi/tokens/"
+export const STATIC_TOKEN = "https://static.gearbox.fi/tokens/";
+export const MULTICALL_ADDRESS = "0x5ba1e12693dc8f9c48aad8770482f4739beed696";