@defisaver/positions-sdk 0.0.1

package/cjs/spark/index.js

@@ -0,0 +1,337 @@
+"use strict";
+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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSparkFullPositionData = exports.getSparkAccountData = exports.getSparkAccountBalances = exports.EMPTY_SPARK_DATA = exports.getSparkMarketsData = exports.sparkEmodeCategoriesMapping = void 0;
+const decimal_js_1 = __importDefault(require("decimal.js"));
+const tokens_1 = require("@defisaver/tokens");
+const utils_1 = require("../services/utils");
+const staking_1 = require("../staking");
+const dsrService_1 = require("../services/dsrService");
+const contracts_1 = require("../contracts");
+const multicall_1 = require("../multicall");
+const sparkHelpers_1 = require("../helpers/sparkHelpers");
+const moneymarket_1 = require("../moneymarket");
+const spark_1 = require("../markets/spark");
+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 = (0, sparkHelpers_1.sparkGetAggregatedPositionData)(Object.assign(Object.assign({}, extractedState), { usedAssets, eModeCategory: a.eModeCategory }));
+        const willStayOverCollateralized = new decimal_js_1.default(afterEnteringCategory.ratio).eq(0) || new decimal_js_1.default(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;
+};
+exports.sparkEmodeCategoriesMapping = sparkEmodeCategoriesMapping;
+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 = (0, contracts_1.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 = (0, contracts_1.SparkViewContract)(web3, network);
+    const loanInfo = yield loanInfoContract.methods.getFullTokensInfo(marketAddress, selectedMarket.assets.map(a => (0, tokens_1.getAssetInfo)((0, utils_1.ethToWeth)(a)).address)).call();
+    const assetsData = loanInfo
+        .map((market, i) => ({
+        symbol: selectedMarket.assets[i],
+        isIsolated: new decimal_js_1.default(market.debtCeilingForIsolationMode).gt(0),
+        debtCeilingForIsolationMode: new decimal_js_1.default(market.debtCeilingForIsolationMode).div(100).toString(),
+        isSiloed: market.isSiloedForBorrowing,
+        eModeCategory: +market.emodeCategory,
+        isolationModeTotalDebt: new decimal_js_1.default(market.isolationModeTotalDebt).div(100).toString(),
+        assetId: Number(market.assetId),
+        underlyingTokenAddress: market.underlyingTokenAddress,
+        supplyRate: new decimal_js_1.default(market.supplyRate.toString()).div(1e25).toString(),
+        borrowRate: new decimal_js_1.default(market.borrowRateVariable.toString()).div(1e25).toString(),
+        borrowRateStable: new decimal_js_1.default(market.borrowRateStable.toString()).div(1e25).toString(),
+        collateralFactor: new decimal_js_1.default(market.collateralFactor.toString()).div(10000).toString(),
+        liquidationRatio: new decimal_js_1.default(market.liquidationRatio.toString()).div(10000).toString(),
+        marketLiquidity: (0, tokens_1.assetAmountInEth)(new decimal_js_1.default(market.totalSupply.toString())
+            .sub(market.totalBorrow.toString())
+            .toString(), selectedMarket.assets[i]),
+        utilization: new decimal_js_1.default(market.totalBorrow.toString())
+            .div(new decimal_js_1.default(market.totalSupply.toString()))
+            .times(100)
+            .toString(),
+        usageAsCollateralEnabled: market.usageAsCollateralEnabled,
+        supplyCap: market.supplyCap,
+        borrowCap: market.borrowCap,
+        totalSupply: (0, tokens_1.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: (0, tokens_1.assetAmountInEth)(market.totalBorrow.toString(), selectedMarket.assets[i]),
+        totalBorrowVar: (0, tokens_1.assetAmountInEth)(market.totalBorrowVar.toString(), selectedMarket.assets[i]),
+        price: new decimal_js_1.default(market.price.toString()).div(1e8).toString(),
+        isolationModeBorrowingEnabled: market.isolationModeBorrowingEnabled,
+        isFlashLoanEnabled: market.isFlashLoanEnabled,
+        eModeCategoryData: {
+            label: market.label,
+            liquidationBonus: new decimal_js_1.default(market.liquidationBonus).div(10000).toString(),
+            liquidationRatio: new decimal_js_1.default(market.liquidationThreshold).div(10000).toString(),
+            collateralFactor: new decimal_js_1.default(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 (0, staking_1.getStETHApr)(mainnetWeb3);
+            market.incentiveSupplyToken = 'wstETH';
+        }
+        if (market.symbol === 'cbETH' && !(0, utils_1.isLayer2Network)(network)) {
+            market.incentiveSupplyApy = yield (0, staking_1.getCbETHApr)(mainnetWeb3);
+            market.incentiveSupplyToken = 'cbETH';
+        }
+        if (market.symbol === 'rETH') {
+            market.incentiveSupplyApy = yield (0, staking_1.getREthApr)(mainnetWeb3);
+            market.incentiveSupplyToken = 'rETH';
+        }
+        if (market.symbol === 'sDAI') {
+            market.incentiveSupplyApy = yield (0, dsrService_1.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 decimal_js_1.default(supplyRewardData.rewardPriceFeed).div(Math.pow(10, supplyRewardData.priceFeedDecimals)).toString();
+            market.incentiveSupplyApy = new decimal_js_1.default(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 decimal_js_1.default(borrowRewardData.rewardPriceFeed).div(Math.pow(10, borrowRewardData.priceFeedDecimals)).toString();
+            market.incentiveBorrowApy = new decimal_js_1.default(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 decimal_js_1.default(a.price).times(a.totalSupply).toString();
+        const bMarket = new decimal_js_1.default(b.price).times(b.totalSupply).toString();
+        return new decimal_js_1.default(bMarket).minus(aMarket).toNumber();
+    })
+        .forEach((assetData, i) => {
+        payload[assetData.symbol] = Object.assign(Object.assign({}, assetData), { sortIndex: i });
+    });
+    return { assetsData: payload };
+});
+exports.getSparkMarketsData = getSparkMarketsData;
+exports.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: [],
+};
+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 = (0, contracts_1.SparkViewContract)(web3, network, block);
+    const market = (0, spark_1.SPARK_V1)(network);
+    const marketAddress = market.providerAddress;
+    const _addresses = market.assets.map(a => (0, tokens_1.getAssetInfo)((0, utils_1.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 (0, multicall_1.multicall)(multicallData, web3, network, block);
+    const loanInfo = [...multicallRes[0][0], ...multicallRes[1][0]];
+    loanInfo.forEach((tokenInfo, i) => {
+        const asset = (0, utils_1.wethToEth)(market.assets[i]);
+        balances = {
+            collateral: Object.assign(Object.assign({}, balances.collateral), { [addressMapping ? (0, tokens_1.getAssetInfo)(asset, network).address.toLowerCase() : asset]: tokenInfo.balance.toString() }),
+            debt: Object.assign(Object.assign({}, balances.debt), { [addressMapping ? (0, tokens_1.getAssetInfo)(asset, network).address.toLowerCase() : asset]: new decimal_js_1.default(tokenInfo.borrowsStable.toString()).add(tokenInfo.borrowsVariable.toString()).toString() }),
+        };
+    });
+    return balances;
+});
+exports.getSparkAccountBalances = getSparkAccountBalances;
+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({}, exports.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 = (0, exports.sparkEmodeCategoriesMapping)(extractedState, {});
+        return payload;
+    }
+    const loanInfoContract = (0, contracts_1.SparkViewContract)(web3, network);
+    const marketAddress = market.providerAddress;
+    const _addresses = market.assets.map((a) => (0, tokens_1.getAssetInfo)((0, utils_1.ethToWeth)(a)).address);
+    const middleAddressIndex = Math.floor(_addresses.length / 2); // split addresses in half to avoid gas limit by multicall
+    const LendingPoolAbi = (0, contracts_1.getConfigContractAbi)(market.lendingPool);
+    const multicallData = [
+        {
+            target: market.lendingPoolAddress,
+            abiItem: LendingPoolAbi.find(({ name }) => name === 'getUserEMode'),
+            params: [address],
+        },
+        {
+            target: loanInfoContract.options.address,
+            abiItem: (0, utils_1.getAbiItem)(loanInfoContract.options.jsonInterface, 'getTokenBalances'),
+            params: [marketAddress, address, _addresses.slice(0, middleAddressIndex)],
+        },
+        {
+            target: loanInfoContract.options.address,
+            abiItem: (0, utils_1.getAbiItem)(loanInfoContract.options.jsonInterface, 'getTokenBalances'),
+            params: [marketAddress, address, _addresses.slice(middleAddressIndex, _addresses.length)],
+        },
+    ];
+    const multicallRes = yield (0, multicall_1.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 = (0, tokens_1.assetAmountInEth)(tokenInfo.balance.toString(), asset);
+        const borrowedStable = (0, tokens_1.assetAmountInEth)(tokenInfo.borrowsStable.toString(), asset);
+        const borrowedVariable = (0, tokens_1.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 decimal_js_1.default(supplied).mul(assetsData[asset].price).toString(), isSupplied, collateral: enabledAsCollateral, stableBorrowRate: new decimal_js_1.default(tokenInfo.stableBorrowRate).div(1e25).toString(), borrowedStable,
+            borrowedVariable, borrowedUsdStable: new decimal_js_1.default(borrowedStable).mul(assetsData[asset].price).toString(), borrowedUsdVariable: new decimal_js_1.default(borrowedVariable).mul(assetsData[asset].price).toString(), borrowed: new decimal_js_1.default(borrowedStable).add(borrowedVariable).toString(), borrowedUsd: new decimal_js_1.default(new decimal_js_1.default(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 }), (0, sparkHelpers_1.sparkGetAggregatedPositionData)(Object.assign(Object.assign({}, extractedState), { usedAssets, eModeCategory: payload.eModeCategory })));
+    payload.eModeCategories = (0, exports.sparkEmodeCategoriesMapping)(extractedState, usedAssets);
+    payload.isInIsolationMode = (0, sparkHelpers_1.sparkIsInIsolationMode)({ usedAssets, assetsData });
+    payload.isInSiloedMode = (0, sparkHelpers_1.sparkIsInIsolationMode)({ usedAssets, assetsData });
+    payload.ratio = payload.borrowedUsd && payload.borrowedUsd !== '0'
+        ? new decimal_js_1.default(payload.borrowLimitUsd).div(payload.borrowedUsd).mul(100).toString()
+        : '0';
+    payload.minRatio = '100';
+    payload.collRatio = payload.borrowedUsd && payload.borrowedUsd !== '0'
+        ? new decimal_js_1.default(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 = (0, moneymarket_1.calculateBorrowingAssetLimit)(item.borrowedUsdStable, payload.borrowLimitUsd);
+            // eslint-disable-next-line no-param-reassign
+            item.variableLimit = (0, moneymarket_1.calculateBorrowingAssetLimit)(item.borrowedUsdVariable, payload.borrowLimitUsd);
+            // eslint-disable-next-line no-param-reassign
+            item.limit = (0, moneymarket_1.calculateBorrowingAssetLimit)(item.borrowedUsd, payload.borrowLimitUsd);
+        }
+    });
+    const { netApy, incentiveUsd, totalInterestUsd } = (0, staking_1.calculateNetApy)(usedAssets, assetsData);
+    payload.netApy = netApy;
+    payload.incentiveUsd = incentiveUsd;
+    payload.totalInterestUsd = totalInterestUsd;
+    return payload;
+});
+exports.getSparkAccountData = getSparkAccountData;
+const getSparkFullPositionData = (web3, network, address, market, mainnetWeb3) => __awaiter(void 0, void 0, void 0, function* () {
+    const marketData = yield (0, exports.getSparkMarketsData)(web3, network, market, mainnetWeb3);
+    const positionData = yield (0, exports.getSparkAccountData)(web3, network, address, { assetsData: marketData.assetsData, selectedMarket: market });
+    return positionData;
+});
+exports.getSparkFullPositionData = getSparkFullPositionData;

package/cjs/staking/index.d.ts

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

package/cjs/staking/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./staking"), exports);

package/cjs/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/cjs/staking/staking.js

@@ -0,0 +1,162 @@
+"use strict";
+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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStETHByWstETHMultiple = exports.getStETHByWstETH = exports.getWstETHByStETH = exports.calculateNetApy = exports.calculateInterestEarned = exports.getStakingApy = exports.getREthApr = exports.getCbETHApr = exports.getStETHApr = void 0;
+const decimal_js_1 = __importDefault(require("decimal.js"));
+const contracts_1 = require("../contracts");
+const common_1 = require("../types/common");
+const constants_1 = require("../constants");
+const multicall_1 = require("../multicall");
+const getStETHApr = (web3, fromBlock = 17900000, blockNumber = 'latest') => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const tokenRebasedEvents = yield (0, contracts_1.LidoContract)(web3, common_1.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 decimal_js_1.default(event.preTotalEther.toString()).div(event.preTotalShares.toString());
+            const postShareRate = new decimal_js_1.default(event.postTotalEther.toString()).div(event.postTotalShares.toString());
+            return new decimal_js_1.default(constants_1.SECONDS_PER_YEAR).mul(new decimal_js_1.default(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;
+    }
+});
+exports.getStETHApr = getStETHApr;
+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 / constants_1.AVG_BLOCK_TIME;
+    const pastBlock = currentBlock - blockDiff;
+    const contract = (0, contracts_1.CbEthContract)(web3, common_1.NetworkNumber.Eth);
+    const [pastRate, currentRate] = yield Promise.all([
+        contract.methods.exchangeRate().call({}, pastBlock),
+        contract.methods.exchangeRate().call({}, currentBlock),
+    ]);
+    const apr = new decimal_js_1.default(currentRate.toString()).sub(pastRate.toString()).div(currentRate.toString())
+        .mul(constants_1.BLOCKS_IN_A_YEAR / blockDiff)
+        .mul(100)
+        .toString();
+    return apr;
+});
+exports.getCbETHApr = getCbETHApr;
+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 / constants_1.AVG_BLOCK_TIME;
+    const pastBlock = currentBlock - blockDiff;
+    const contract = (0, contracts_1.REthContract)(web3, common_1.NetworkNumber.Eth);
+    const [pastRate, currentRate] = yield Promise.all([
+        contract.methods.getExchangeRate().call({}, pastBlock),
+        contract.methods.getExchangeRate().call({}, currentBlock),
+    ]);
+    const apr = new decimal_js_1.default(currentRate.toString()).sub(pastRate.toString()).div(currentRate.toString())
+        .mul(constants_1.BLOCKS_IN_A_YEAR / blockDiff)
+        .mul(100)
+        .toString();
+    return apr;
+});
+exports.getREthApr = getREthApr;
+const getStakingApy = (asset, web3, blockNumber = 'latest', fromBlock = undefined) => {
+    if (asset === 'stETH' || asset === 'wstETH')
+        return (0, exports.getStETHApr)(web3, fromBlock, blockNumber);
+    if (asset === 'cbETH')
+        return (0, exports.getCbETHApr)(web3, blockNumber);
+    if (asset === 'rETH')
+        return (0, exports.getREthApr)(web3, blockNumber);
+};
+exports.getStakingApy = getStakingApy;
+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) / constants_1.BLOCKS_IN_A_YEAR)), (constants_1.BLOCKS_IN_A_YEAR * interval)))) - +principal; // eslint-disable-line
+};
+exports.calculateInterestEarned = calculateInterestEarned;
+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 decimal_js_1.default(acc.suppliedUsd).add(amount).toString();
+            const rate = isMorpho
+                ? usedAsset.supplyRate === '0' ? assetData.supplyRateP2P : usedAsset.supplyRate
+                : assetData.supplyRate;
+            const supplyInterest = (0, exports.calculateInterestEarned)(amount, rate, 'year', true);
+            acc.supplyInterest = new decimal_js_1.default(acc.supplyInterest).add(supplyInterest.toString()).toString();
+            if (assetData.incentiveSupplyApy) {
+                // take COMP/AAVE yield into account
+                const incentiveInterest = (0, exports.calculateInterestEarned)(amount, assetData.incentiveSupplyApy, 'year', true);
+                acc.incentiveUsd = new decimal_js_1.default(acc.incentiveUsd).add(incentiveInterest).toString();
+            }
+        }
+        if (usedAsset.isBorrowed) {
+            const amount = usedAsset.borrowedUsd;
+            acc.borrowedUsd = new decimal_js_1.default(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 = (0, exports.calculateInterestEarned)(amount, rate, 'year', true);
+            acc.borrowInterest = new decimal_js_1.default(acc.borrowInterest).sub(borrowInterest.toString()).toString();
+            if (assetData.incentiveBorrowApy) {
+                // take COMP/AAVE yield into account
+                const incentiveInterest = (0, exports.calculateInterestEarned)(amount, assetData.incentiveBorrowApy, 'year', true);
+                acc.incentiveUsd = new decimal_js_1.default(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 decimal_js_1.default(borrowInterest).add(supplyInterest).add(incentiveUsd).toString();
+    const balance = new decimal_js_1.default(suppliedUsd).sub(borrowedUsd);
+    const netApy = new decimal_js_1.default(totalInterestUsd).div(balance).times(100).toString();
+    return { netApy, totalInterestUsd, incentiveUsd };
+};
+exports.calculateNetApy = calculateNetApy;
+const getWstETHByStETH = (stETHAmount, web3) => __awaiter(void 0, void 0, void 0, function* () { return (0, contracts_1.wstETHContract)(web3, common_1.NetworkNumber.Eth).methods.getWstETHByStETH(stETHAmount).call(); });
+exports.getWstETHByStETH = getWstETHByStETH;
+const getStETHByWstETH = (wstETHAmount, web3) => __awaiter(void 0, void 0, void 0, function* () { return (0, contracts_1.wstETHContract)(web3, common_1.NetworkNumber.Eth).methods.getStETHByWstETH(wstETHAmount).call(); });
+exports.getStETHByWstETH = getStETHByWstETH;
+const getStETHByWstETHMultiple = (wstEthAmounts, web3) => __awaiter(void 0, void 0, void 0, function* () {
+    const contract = (0, contracts_1.wstETHContract)(web3, common_1.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 (0, multicall_1.multicall)(calls, web3);
+    return stEthAmounts.map((arr) => arr[0]);
+});
+exports.getStETHByWstETHMultiple = getStETHByWstETHMultiple;