@defisaver/positions-sdk 0.0.1

package/esm/spark/index.js

@@ -0,0 +1,326 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import Dec from 'decimal.js';
+import { assetAmountInEth, getAssetInfo } from '@defisaver/tokens';
+import { ethToWeth, getAbiItem, isLayer2Network, wethToEth, } from '../services/utils';
+import { calculateNetApy, getCbETHApr, getREthApr, getStETHApr, } from '../staking';
+import { getDsrApy } from '../services/dsrService';
+import { SparkIncentiveDataProviderContract, SparkViewContract, getConfigContractAbi, } from '../contracts';
+import { multicall } from '../multicall';
+import { sparkGetAggregatedPositionData, sparkIsInIsolationMode } from '../helpers/sparkHelpers';
+import { calculateBorrowingAssetLimit } from '../moneymarket';
+import { SPARK_V1 } from '../markets/spark';
+export const sparkEmodeCategoriesMapping = (extractedState, usedAssets) => {
+    const { assetsData } = extractedState;
+    const usedAssetsValues = Object.values(usedAssets);
+    const categoriesMapping = {};
+    Object.values(assetsData).forEach((a) => {
+        var _a;
+        const borrowingOnlyFromCategory = a.eModeCategory === 0
+            ? true
+            : !usedAssetsValues.filter(u => u.isBorrowed && u.eModeCategory !== a.eModeCategory).length;
+        const afterEnteringCategory = sparkGetAggregatedPositionData(Object.assign(Object.assign({}, extractedState), { usedAssets, eModeCategory: a.eModeCategory }));
+        const willStayOverCollateralized = new Dec(afterEnteringCategory.ratio).eq(0) || new Dec(afterEnteringCategory.ratio).gt(afterEnteringCategory.liqPercent);
+        const enteringTerms = [borrowingOnlyFromCategory, willStayOverCollateralized];
+        categoriesMapping[a.eModeCategory] = {
+            enteringTerms,
+            canEnterCategory: !enteringTerms.includes(false),
+            id: a.eModeCategory,
+            data: a.eModeCategoryData,
+            assets: a.eModeCategory === 0 ? [] : [...(((_a = categoriesMapping[a.eModeCategory]) === null || _a === void 0 ? void 0 : _a.assets) || []), a.symbol],
+            enabledData: {
+                ratio: afterEnteringCategory.ratio,
+                liqRatio: afterEnteringCategory.liqRatio,
+                liqPercent: afterEnteringCategory.liqPercent,
+                collRatio: afterEnteringCategory.collRatio,
+            },
+        };
+    });
+    return categoriesMapping;
+};
+export const getSparkMarketsData = (web3, network, selectedMarket, mainnetWeb3) => __awaiter(void 0, void 0, void 0, function* () {
+    const marketAddress = selectedMarket.providerAddress;
+    let rewardInfo = [];
+    if (network === 10) {
+        const sparkIncentivesContract = SparkIncentiveDataProviderContract(web3, network);
+        rewardInfo = yield sparkIncentivesContract.methods.getReservesIncentivesData(marketAddress).call();
+        rewardInfo = rewardInfo.reduce((all, market) => {
+            // eslint-disable-next-line no-param-reassign
+            all[market.underlyingAsset] = market;
+            return all;
+        }, {});
+    }
+    const loanInfoContract = SparkViewContract(web3, network);
+    const loanInfo = yield loanInfoContract.methods.getFullTokensInfo(marketAddress, selectedMarket.assets.map(a => getAssetInfo(ethToWeth(a)).address)).call();
+    const assetsData = loanInfo
+        .map((market, i) => ({
+        symbol: selectedMarket.assets[i],
+        isIsolated: new Dec(market.debtCeilingForIsolationMode).gt(0),
+        debtCeilingForIsolationMode: new Dec(market.debtCeilingForIsolationMode).div(100).toString(),
+        isSiloed: market.isSiloedForBorrowing,
+        eModeCategory: +market.emodeCategory,
+        isolationModeTotalDebt: new Dec(market.isolationModeTotalDebt).div(100).toString(),
+        assetId: Number(market.assetId),
+        underlyingTokenAddress: market.underlyingTokenAddress,
+        supplyRate: new Dec(market.supplyRate.toString()).div(1e25).toString(),
+        borrowRate: new Dec(market.borrowRateVariable.toString()).div(1e25).toString(),
+        borrowRateStable: new Dec(market.borrowRateStable.toString()).div(1e25).toString(),
+        collateralFactor: new Dec(market.collateralFactor.toString()).div(10000).toString(),
+        liquidationRatio: new Dec(market.liquidationRatio.toString()).div(10000).toString(),
+        marketLiquidity: assetAmountInEth(new Dec(market.totalSupply.toString())
+            .sub(market.totalBorrow.toString())
+            .toString(), selectedMarket.assets[i]),
+        utilization: new Dec(market.totalBorrow.toString())
+            .div(new Dec(market.totalSupply.toString()))
+            .times(100)
+            .toString(),
+        usageAsCollateralEnabled: market.usageAsCollateralEnabled,
+        supplyCap: market.supplyCap,
+        borrowCap: market.borrowCap,
+        totalSupply: assetAmountInEth(market.totalSupply.toString(), selectedMarket.assets[i]),
+        isInactive: !market.isActive,
+        isFrozen: market.isFrozen,
+        isPaused: market.isPaused,
+        canBeBorrowed: market.isActive && !market.isPaused && !market.isFrozen && market.borrowingEnabled,
+        canBeSupplied: market.isActive && !market.isPaused && !market.isFrozen,
+        canBeWithdrawn: market.isActive && !market.isPaused,
+        canBePayBacked: market.isActive && !market.isPaused,
+        disabledStableBorrowing: !market.stableBorrowRateEnabled,
+        totalBorrow: assetAmountInEth(market.totalBorrow.toString(), selectedMarket.assets[i]),
+        totalBorrowVar: assetAmountInEth(market.totalBorrowVar.toString(), selectedMarket.assets[i]),
+        price: new Dec(market.price.toString()).div(1e8).toString(),
+        isolationModeBorrowingEnabled: market.isolationModeBorrowingEnabled,
+        isFlashLoanEnabled: market.isFlashLoanEnabled,
+        eModeCategoryData: {
+            label: market.label,
+            liquidationBonus: new Dec(market.liquidationBonus).div(10000).toString(),
+            liquidationRatio: new Dec(market.liquidationThreshold).div(10000).toString(),
+            collateralFactor: new Dec(market.ltv).div(10000).toString(),
+            priceSource: market.priceSource,
+        },
+    }));
+    yield Promise.all(assetsData.map((market) => __awaiter(void 0, void 0, void 0, function* () {
+        /* eslint-disable no-param-reassign */
+        const rewardForMarket = rewardInfo[market.underlyingTokenAddress];
+        if (market.symbol === 'wstETH') {
+            market.incentiveSupplyApy = yield getStETHApr(mainnetWeb3);
+            market.incentiveSupplyToken = 'wstETH';
+        }
+        if (market.symbol === 'cbETH' && !isLayer2Network(network)) {
+            market.incentiveSupplyApy = yield getCbETHApr(mainnetWeb3);
+            market.incentiveSupplyToken = 'cbETH';
+        }
+        if (market.symbol === 'rETH') {
+            market.incentiveSupplyApy = yield getREthApr(mainnetWeb3);
+            market.incentiveSupplyToken = 'rETH';
+        }
+        if (market.symbol === 'sDAI') {
+            market.incentiveSupplyApy = yield getDsrApy(web3, network);
+            market.incentiveSupplyToken = 'sDAI';
+        }
+        if (market.canBeBorrowed && market.incentiveSupplyApy) {
+            market.incentiveBorrowApy = `-${market.incentiveSupplyApy}`;
+            market.incentiveBorrowToken = market.incentiveSupplyToken;
+        }
+        if (!rewardForMarket)
+            return;
+        const supplyRewardData = rewardForMarket.aIncentiveData.rewardsTokenInformation[0];
+        if (supplyRewardData) {
+            if (supplyRewardData.emissionEndTimestamp * 1000 < Date.now())
+                return;
+            market.incentiveSupplyToken = supplyRewardData.rewardTokenSymbol;
+            const supplyEmissionPerSecond = supplyRewardData.emissionPerSecond;
+            const supplyRewardPrice = new Dec(supplyRewardData.rewardPriceFeed).div(Math.pow(10, supplyRewardData.priceFeedDecimals)).toString();
+            market.incentiveSupplyApy = new Dec(supplyEmissionPerSecond).div((Math.pow(10, supplyRewardData.rewardTokenDecimals)) / 100)
+                .mul(365 * 24 * 3600)
+                .mul(supplyRewardPrice)
+                .div(market.price)
+                .div(market.totalSupply)
+                .toString();
+        }
+        const borrowRewardData = rewardForMarket.vIncentiveData.rewardsTokenInformation[0];
+        if (borrowRewardData) {
+            if (borrowRewardData.emissionEndTimestamp * 1000 < Date.now())
+                return;
+            market.incentiveBorrowToken = borrowRewardData.rewardTokenSymbol;
+            const supplyEmissionPerSecond = borrowRewardData.emissionPerSecond;
+            const supplyRewardPrice = new Dec(borrowRewardData.rewardPriceFeed).div(Math.pow(10, borrowRewardData.priceFeedDecimals)).toString();
+            market.incentiveBorrowApy = new Dec(supplyEmissionPerSecond).div((Math.pow(10, borrowRewardData.rewardTokenDecimals)) / 100)
+                .mul(365 * 24 * 3600)
+                .mul(supplyRewardPrice)
+                .div(market.price)
+                .div(market.totalBorrowVar)
+                .toString();
+        }
+        /* eslint-enable no-param-reassign */
+    })));
+    const payload = {};
+    // Sort by market size
+    assetsData
+        .sort((a, b) => {
+        const aMarket = new Dec(a.price).times(a.totalSupply).toString();
+        const bMarket = new Dec(b.price).times(b.totalSupply).toString();
+        return new Dec(bMarket).minus(aMarket).toNumber();
+    })
+        .forEach((assetData, i) => {
+        payload[assetData.symbol] = Object.assign(Object.assign({}, assetData), { sortIndex: i });
+    });
+    return { assetsData: payload };
+});
+export const EMPTY_SPARK_DATA = {
+    usedAssets: {},
+    suppliedUsd: '0',
+    borrowedUsd: '0',
+    borrowLimitUsd: '0',
+    leftToBorrowUsd: '0',
+    ratio: '0',
+    minRatio: '0',
+    netApy: '0',
+    incentiveUsd: '0',
+    totalInterestUsd: '0',
+    eModeCategory: 0,
+    isInIsolationMode: false,
+    isInSiloedMode: false,
+    collRatio: '0',
+    suppliedCollateralUsd: '0',
+    totalSupplied: '0',
+    eModeCategories: [],
+};
+export const getSparkAccountBalances = (web3, network, block, addressMapping, address) => __awaiter(void 0, void 0, void 0, function* () {
+    let balances = {
+        collateral: {},
+        debt: {},
+    };
+    if (!address) {
+        return balances;
+    }
+    const loanInfoContract = SparkViewContract(web3, network, block);
+    const market = SPARK_V1(network);
+    const marketAddress = market.providerAddress;
+    const _addresses = market.assets.map(a => getAssetInfo(ethToWeth(a), network).address);
+    // split addresses in half to avoid gas limit by multicall
+    const middleAddressIndex = Math.floor(_addresses.length / 2);
+    const multicallData = [
+        {
+            target: loanInfoContract.options.address,
+            abiItem: loanInfoContract.options.jsonInterface.find(({ name }) => name === 'getTokenBalances'),
+            params: [marketAddress, address, _addresses.slice(0, middleAddressIndex)],
+        },
+        {
+            target: loanInfoContract.options.address,
+            abiItem: loanInfoContract.options.jsonInterface.find(({ name }) => name === 'getTokenBalances'),
+            params: [marketAddress, address, _addresses.slice(middleAddressIndex, _addresses.length)],
+        },
+    ];
+    const multicallRes = yield multicall(multicallData, web3, network, block);
+    const loanInfo = [...multicallRes[0][0], ...multicallRes[1][0]];
+    loanInfo.forEach((tokenInfo, i) => {
+        const asset = wethToEth(market.assets[i]);
+        balances = {
+            collateral: Object.assign(Object.assign({}, balances.collateral), { [addressMapping ? getAssetInfo(asset, network).address.toLowerCase() : asset]: tokenInfo.balance.toString() }),
+            debt: Object.assign(Object.assign({}, balances.debt), { [addressMapping ? getAssetInfo(asset, network).address.toLowerCase() : asset]: new Dec(tokenInfo.borrowsStable.toString()).add(tokenInfo.borrowsVariable.toString()).toString() }),
+        };
+    });
+    return balances;
+});
+export const getSparkAccountData = (web3, network, address, extractedState) => __awaiter(void 0, void 0, void 0, function* () {
+    const { selectedMarket: market, assetsData, } = extractedState;
+    let payload = Object.assign(Object.assign({}, EMPTY_SPARK_DATA), { lastUpdated: Date.now() });
+    if (!address) {
+        // structure that this function returns is complex and dynamic so i didnt want to hardcode it in EMPTY_SPARK_DATA
+        // This case only triggers if user doesnt have proxy and data is refetched once proxy is created
+        // TODO when refactoring spark figure out if this is the best solution.
+        payload.eModeCategories = sparkEmodeCategoriesMapping(extractedState, {});
+        return payload;
+    }
+    const loanInfoContract = SparkViewContract(web3, network);
+    const marketAddress = market.providerAddress;
+    const _addresses = market.assets.map((a) => getAssetInfo(ethToWeth(a)).address);
+    const middleAddressIndex = Math.floor(_addresses.length / 2); // split addresses in half to avoid gas limit by multicall
+    const LendingPoolAbi = getConfigContractAbi(market.lendingPool);
+    const multicallData = [
+        {
+            target: market.lendingPoolAddress,
+            abiItem: LendingPoolAbi.find(({ name }) => name === 'getUserEMode'),
+            params: [address],
+        },
+        {
+            target: loanInfoContract.options.address,
+            abiItem: getAbiItem(loanInfoContract.options.jsonInterface, 'getTokenBalances'),
+            params: [marketAddress, address, _addresses.slice(0, middleAddressIndex)],
+        },
+        {
+            target: loanInfoContract.options.address,
+            abiItem: getAbiItem(loanInfoContract.options.jsonInterface, 'getTokenBalances'),
+            params: [marketAddress, address, _addresses.slice(middleAddressIndex, _addresses.length)],
+        },
+    ];
+    const multicallRes = yield multicall(multicallData, web3, network);
+    const loanInfo = [...multicallRes[1][0], ...multicallRes[2][0]];
+    const usedAssets = {};
+    loanInfo.forEach((tokenInfo, i) => {
+        const asset = market.assets[i];
+        const isSupplied = tokenInfo.balance.toString() !== '0';
+        const isBorrowed = tokenInfo.borrowsStable.toString() !== '0' || tokenInfo.borrowsVariable.toString() !== '0';
+        if (!isSupplied && !isBorrowed)
+            return;
+        const supplied = assetAmountInEth(tokenInfo.balance.toString(), asset);
+        const borrowedStable = assetAmountInEth(tokenInfo.borrowsStable.toString(), asset);
+        const borrowedVariable = assetAmountInEth(tokenInfo.borrowsVariable.toString(), asset);
+        const enabledAsCollateral = assetsData[asset].usageAsCollateralEnabled ? tokenInfo.enabledAsCollateral : false;
+        let interestMode;
+        if (borrowedVariable === '0' && borrowedStable !== '0') {
+            interestMode = '1';
+        }
+        else if (borrowedVariable !== '0' && borrowedStable === '0') {
+            interestMode = '2';
+        }
+        else {
+            interestMode = 'both';
+        }
+        if (!usedAssets[asset])
+            usedAssets[asset] = {};
+        usedAssets[asset] = Object.assign(Object.assign({}, usedAssets[asset]), { symbol: asset, supplied, suppliedUsd: new Dec(supplied).mul(assetsData[asset].price).toString(), isSupplied, collateral: enabledAsCollateral, stableBorrowRate: new Dec(tokenInfo.stableBorrowRate).div(1e25).toString(), borrowedStable,
+            borrowedVariable, borrowedUsdStable: new Dec(borrowedStable).mul(assetsData[asset].price).toString(), borrowedUsdVariable: new Dec(borrowedVariable).mul(assetsData[asset].price).toString(), borrowed: new Dec(borrowedStable).add(borrowedVariable).toString(), borrowedUsd: new Dec(new Dec(borrowedVariable).add(borrowedStable)).mul(assetsData[asset].price).toString(), isBorrowed, eModeCategory: assetsData[asset].eModeCategory, interestMode });
+    });
+    payload.eModeCategory = +multicallRes[0][0];
+    payload = Object.assign(Object.assign(Object.assign({}, payload), { usedAssets }), sparkGetAggregatedPositionData(Object.assign(Object.assign({}, extractedState), { usedAssets, eModeCategory: payload.eModeCategory })));
+    payload.eModeCategories = sparkEmodeCategoriesMapping(extractedState, usedAssets);
+    payload.isInIsolationMode = sparkIsInIsolationMode({ usedAssets, assetsData });
+    payload.isInSiloedMode = sparkIsInIsolationMode({ usedAssets, assetsData });
+    payload.ratio = payload.borrowedUsd && payload.borrowedUsd !== '0'
+        ? new Dec(payload.borrowLimitUsd).div(payload.borrowedUsd).mul(100).toString()
+        : '0';
+    payload.minRatio = '100';
+    payload.collRatio = payload.borrowedUsd && payload.borrowedUsd !== '0'
+        ? new Dec(payload.suppliedCollateralUsd).div(payload.borrowedUsd).mul(100).toString()
+        : '0';
+    // Calculate borrow limits per asset
+    Object.values(payload.usedAssets).forEach((item) => {
+        if (item.isBorrowed) {
+            // eslint-disable-next-line no-param-reassign
+            item.stableLimit = calculateBorrowingAssetLimit(item.borrowedUsdStable, payload.borrowLimitUsd);
+            // eslint-disable-next-line no-param-reassign
+            item.variableLimit = calculateBorrowingAssetLimit(item.borrowedUsdVariable, payload.borrowLimitUsd);
+            // eslint-disable-next-line no-param-reassign
+            item.limit = calculateBorrowingAssetLimit(item.borrowedUsd, payload.borrowLimitUsd);
+        }
+    });
+    const { netApy, incentiveUsd, totalInterestUsd } = calculateNetApy(usedAssets, assetsData);
+    payload.netApy = netApy;
+    payload.incentiveUsd = incentiveUsd;
+    payload.totalInterestUsd = totalInterestUsd;
+    return payload;
+});
+export const getSparkFullPositionData = (web3, network, address, market, mainnetWeb3) => __awaiter(void 0, void 0, void 0, function* () {
+    const marketData = yield getSparkMarketsData(web3, network, market, mainnetWeb3);
+    const positionData = yield getSparkAccountData(web3, network, address, { assetsData: marketData.assetsData, selectedMarket: market });
+    return positionData;
+});

package/esm/staking/index.d.ts

@@ -0,0 +1 @@
+export * from './staking';

package/esm/staking/index.js

@@ -0,0 +1 @@
+export * from './staking';

package/esm/staking/staking.d.ts

@@ -0,0 +1,15 @@
+import Web3 from 'web3';
+import { MMAssetsData, MMUsedAssets } from '../types/common';
+export declare const getStETHApr: (web3: Web3, fromBlock?: number, blockNumber?: 'latest' | number) => Promise<any>;
+export declare const getCbETHApr: (web3: Web3, blockNumber?: 'latest' | number) => Promise<string>;
+export declare const getREthApr: (web3: Web3, blockNumber?: 'latest' | number) => Promise<string>;
+export declare const getStakingApy: (asset: string, web3: Web3, blockNumber?: 'latest' | number, fromBlock?: number | undefined) => Promise<any> | undefined;
+export declare const calculateInterestEarned: (principal: string, interest: string, type: string, apy?: boolean) => number;
+export declare const calculateNetApy: (usedAssets: MMUsedAssets, assetsData: MMAssetsData, isMorpho?: boolean) => {
+    netApy: string;
+    totalInterestUsd: string;
+    incentiveUsd: string;
+};
+export declare const getWstETHByStETH: (stETHAmount: string | number, web3: Web3) => Promise<string>;
+export declare const getStETHByWstETH: (wstETHAmount: string | number, web3: Web3) => Promise<string>;
+export declare const getStETHByWstETHMultiple: (wstEthAmounts: string[] | number[], web3: Web3) => Promise<any[]>;

package/esm/staking/staking.js

@@ -0,0 +1,147 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import Dec from 'decimal.js';
+import { CbEthContract, LidoContract, REthContract, wstETHContract, } from '../contracts';
+import { NetworkNumber } from '../types/common';
+import { BLOCKS_IN_A_YEAR, SECONDS_PER_YEAR, AVG_BLOCK_TIME } from '../constants';
+import { multicall } from '../multicall';
+export const getStETHApr = (web3, fromBlock = 17900000, blockNumber = 'latest') => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const tokenRebasedEvents = yield LidoContract(web3, NetworkNumber.Eth).getPastEvents('TokenRebased', { fromBlock, toBlock: blockNumber });
+        tokenRebasedEvents.sort((a, b) => b.blockNumber - a.blockNumber); // sort from highest to lowest block number
+        const movingAverage = 7;
+        const aprs = tokenRebasedEvents.slice(0, movingAverage).map(({ returnValues: event }) => {
+            const preShareRate = new Dec(event.preTotalEther.toString()).div(event.preTotalShares.toString());
+            const postShareRate = new Dec(event.postTotalEther.toString()).div(event.postTotalShares.toString());
+            return new Dec(SECONDS_PER_YEAR).mul(new Dec(postShareRate).sub(preShareRate).div(preShareRate))
+                .div(event.timeElapsed.toString()).mul(100)
+                .toNumber();
+        });
+        return aprs.reduce((a, b) => a + b, 0) / aprs.length;
+    }
+    catch (e) {
+        console.warn('Failed to fetch stETH APY from events, falling back to Lido API');
+        const res = yield fetch('https://eth-api.lido.fi/v1/protocol/steth/apr/sma');
+        const data = yield res.json();
+        return data.data.smaApr;
+    }
+});
+export const getCbETHApr = (web3, blockNumber = 'latest') => __awaiter(void 0, void 0, void 0, function* () {
+    let currentBlock = blockNumber;
+    if (blockNumber === 'latest')
+        currentBlock = yield web3.eth.getBlockNumber();
+    const blockDiff = 6 * 24 * 60 * 60 / AVG_BLOCK_TIME;
+    const pastBlock = currentBlock - blockDiff;
+    const contract = CbEthContract(web3, NetworkNumber.Eth);
+    const [pastRate, currentRate] = yield Promise.all([
+        contract.methods.exchangeRate().call({}, pastBlock),
+        contract.methods.exchangeRate().call({}, currentBlock),
+    ]);
+    const apr = new Dec(currentRate.toString()).sub(pastRate.toString()).div(currentRate.toString())
+        .mul(BLOCKS_IN_A_YEAR / blockDiff)
+        .mul(100)
+        .toString();
+    return apr;
+});
+export const getREthApr = (web3, blockNumber = 'latest') => __awaiter(void 0, void 0, void 0, function* () {
+    let currentBlock = blockNumber;
+    if (blockNumber === 'latest')
+        currentBlock = yield web3.eth.getBlockNumber();
+    const blockDiff = 8 * 24 * 60 * 60 / AVG_BLOCK_TIME;
+    const pastBlock = currentBlock - blockDiff;
+    const contract = REthContract(web3, NetworkNumber.Eth);
+    const [pastRate, currentRate] = yield Promise.all([
+        contract.methods.getExchangeRate().call({}, pastBlock),
+        contract.methods.getExchangeRate().call({}, currentBlock),
+    ]);
+    const apr = new Dec(currentRate.toString()).sub(pastRate.toString()).div(currentRate.toString())
+        .mul(BLOCKS_IN_A_YEAR / blockDiff)
+        .mul(100)
+        .toString();
+    return apr;
+});
+export const getStakingApy = (asset, web3, blockNumber = 'latest', fromBlock = undefined) => {
+    if (asset === 'stETH' || asset === 'wstETH')
+        return getStETHApr(web3, fromBlock, blockNumber);
+    if (asset === 'cbETH')
+        return getCbETHApr(web3, blockNumber);
+    if (asset === 'rETH')
+        return getREthApr(web3, blockNumber);
+};
+export const calculateInterestEarned = (principal, interest, type, apy = false) => {
+    let interval = 1;
+    if (+interest === 0)
+        return 0;
+    if (type === 'month')
+        interval = 1 / 12;
+    if (type === 'week')
+        interval = 1 / 52.1429;
+    if (apy) {
+        // interest rate already compounded
+        return (+principal * (1 + (+interest / 100 * interval))) - +principal;
+    }
+    return (+principal * (Math.pow(((1 + (+interest / 100) / BLOCKS_IN_A_YEAR)), (BLOCKS_IN_A_YEAR * interval)))) - +principal; // eslint-disable-line
+};
+export const calculateNetApy = (usedAssets, assetsData, isMorpho = false) => {
+    const sumValues = Object.values(usedAssets).reduce((_acc, usedAsset) => {
+        const acc = Object.assign({}, _acc);
+        const assetData = assetsData[usedAsset.symbol];
+        if (usedAsset.isSupplied) {
+            const amount = usedAsset.suppliedUsd;
+            acc.suppliedUsd = new Dec(acc.suppliedUsd).add(amount).toString();
+            const rate = isMorpho
+                ? usedAsset.supplyRate === '0' ? assetData.supplyRateP2P : usedAsset.supplyRate
+                : assetData.supplyRate;
+            const supplyInterest = calculateInterestEarned(amount, rate, 'year', true);
+            acc.supplyInterest = new Dec(acc.supplyInterest).add(supplyInterest.toString()).toString();
+            if (assetData.incentiveSupplyApy) {
+                // take COMP/AAVE yield into account
+                const incentiveInterest = calculateInterestEarned(amount, assetData.incentiveSupplyApy, 'year', true);
+                acc.incentiveUsd = new Dec(acc.incentiveUsd).add(incentiveInterest).toString();
+            }
+        }
+        if (usedAsset.isBorrowed) {
+            const amount = usedAsset.borrowedUsd;
+            acc.borrowedUsd = new Dec(acc.borrowedUsd).add(amount).toString();
+            const rate = isMorpho
+                ? usedAsset.borrowRate === '0' ? assetData.borrowRateP2P : usedAsset.borrowRate
+                : usedAsset.symbol === 'GHO'
+                    ? usedAsset.discountedBorrowRate
+                    : ((usedAsset === null || usedAsset === void 0 ? void 0 : usedAsset.interestMode) === '1' ? usedAsset.stableBorrowRate : assetData.borrowRate);
+            const borrowInterest = calculateInterestEarned(amount, rate, 'year', true);
+            acc.borrowInterest = new Dec(acc.borrowInterest).sub(borrowInterest.toString()).toString();
+            if (assetData.incentiveBorrowApy) {
+                // take COMP/AAVE yield into account
+                const incentiveInterest = calculateInterestEarned(amount, assetData.incentiveBorrowApy, 'year', true);
+                acc.incentiveUsd = new Dec(acc.incentiveUsd).add(incentiveInterest).toString();
+            }
+        }
+        return acc;
+    }, {
+        borrowInterest: '0', supplyInterest: '0', incentiveUsd: '0', borrowedUsd: '0', suppliedUsd: '0',
+    });
+    const { borrowedUsd, suppliedUsd, borrowInterest, supplyInterest, incentiveUsd, } = sumValues;
+    const totalInterestUsd = new Dec(borrowInterest).add(supplyInterest).add(incentiveUsd).toString();
+    const balance = new Dec(suppliedUsd).sub(borrowedUsd);
+    const netApy = new Dec(totalInterestUsd).div(balance).times(100).toString();
+    return { netApy, totalInterestUsd, incentiveUsd };
+};
+export const getWstETHByStETH = (stETHAmount, web3) => __awaiter(void 0, void 0, void 0, function* () { return wstETHContract(web3, NetworkNumber.Eth).methods.getWstETHByStETH(stETHAmount).call(); });
+export const getStETHByWstETH = (wstETHAmount, web3) => __awaiter(void 0, void 0, void 0, function* () { return wstETHContract(web3, NetworkNumber.Eth).methods.getStETHByWstETH(wstETHAmount).call(); });
+export const getStETHByWstETHMultiple = (wstEthAmounts, web3) => __awaiter(void 0, void 0, void 0, function* () {
+    const contract = wstETHContract(web3, NetworkNumber.Eth);
+    const calls = wstEthAmounts.map((amount) => ({
+        target: contract.options.address,
+        abiItem: contract.options.jsonInterface.find((i) => i.name === 'getStETHByWstETH'),
+        params: [amount],
+    }));
+    const stEthAmounts = yield multicall(calls, web3);
+    return stEthAmounts.map((arr) => arr[0]);
+});