@defisaver/positions-sdk 0.0.1

package/esm/morphoAaveV3/index.js

@@ -0,0 +1,432 @@
+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 { assetAmountInEth, assetAmountInWei, getAssetInfo, getAssetInfoByAddress, } from '@defisaver/tokens';
+import { MorphoAaveMath } from '@morpho-org/morpho-aave-v3-sdk/lib/maths/AaveV3.maths';
+import PoolInterestRates from '@morpho-org/morpho-aave-v3-sdk/lib/maths/PoolInterestRates';
+import P2PInterestRates from '@morpho-org/morpho-aave-v3-sdk/lib/maths/P2PInterestRates';
+import { BigNumber } from '@ethersproject/bignumber';
+import Dec from 'decimal.js';
+import { ethToWeth, ethToWethByAddress, getAbiItem, isLayer2Network, wethToEthByAddress, } from '../services/utils';
+import { createContractWrapper, getConfigContractAbi, getConfigContractAddress, } from '../contracts';
+import { multicall } from '../multicall';
+import { getCbETHApr, getREthApr, getStETHApr } from '../staking';
+import { getDsrApy } from '../services/dsrService';
+import { calculateBorrowingAssetLimit } from '../moneymarket';
+import { EMPTY_AAVE_DATA } from '../aaveV3';
+import { aaveAnyGetAggregatedPositionData } from '../helpers/aaveHelpers';
+import { MORPHO_AAVE_V3_ETH } from '../markets/aave';
+const morphoAaveMath = new MorphoAaveMath();
+const poolInterestRates = new PoolInterestRates();
+const p2pInterestRates = new P2PInterestRates();
+const computeMorphoMarketData = (loanInfo, morphoMarketData, aaveIndexes) => {
+    const { newPoolSupplyIndex, newPoolBorrowIndex } = poolInterestRates.computePoolIndexes({
+        lastPoolSupplyIndex: BigNumber.from(aaveIndexes.liquidityIndex),
+        lastPoolBorrowIndex: BigNumber.from(aaveIndexes.variableBorrowIndex),
+        lastUpdateTimestamp: BigNumber.from(aaveIndexes.lastUpdateTimestamp),
+        poolBorrowRatePerYear: BigNumber.from(loanInfo.borrowRateVariable),
+        poolSupplyRatePerYear: BigNumber.from(loanInfo.supplyRate),
+        currentTimestamp: BigNumber.from(new Dec(Date.now()).div(1000).toDP(0).toString()),
+    });
+    const proportionIdle = new Dec(morphoMarketData.idleSupply).eq(0)
+        ? '0'
+        : Dec.min(morphoAaveMath.INDEX_ONE.toString(), morphoAaveMath.indexDiv(morphoMarketData.idleSupply, morphoAaveMath.indexMul(morphoMarketData.deltas.supply.scaledP2PTotal, morphoMarketData.indexes.supply.p2pIndex).toString()).toString()).toString();
+    const supplyProportionDelta = new Dec(morphoMarketData.idleSupply).eq(0)
+        ? '0'
+        : Dec.min(new Dec(morphoAaveMath.INDEX_ONE.toString()).sub(proportionIdle).toString(), morphoAaveMath.indexDiv(morphoAaveMath.indexMul(morphoMarketData.deltas.supply.scaledDelta, newPoolSupplyIndex), morphoAaveMath.indexMul(morphoMarketData.deltas.supply.scaledP2PTotal, morphoMarketData.indexes.supply.p2pIndex)).toString()).toString();
+    const borrowProportionDelta = new Dec(morphoMarketData.idleSupply).eq(0)
+        ? '0'
+        : Dec.min(morphoAaveMath.INDEX_ONE.toString(), morphoAaveMath.indexDiv(morphoAaveMath.indexMul(morphoMarketData.deltas.borrow.scaledDelta, newPoolBorrowIndex), morphoAaveMath.indexMul(morphoMarketData.deltas.borrow.scaledP2PTotal, morphoMarketData.indexes.borrow.p2pIndex)).toString()).toString();
+    const apys = morphoAaveMath.computeApysFromRates(BigNumber.from(loanInfo.supplyRate), BigNumber.from(loanInfo.borrowRateVariable), BigNumber.from(morphoMarketData.p2pIndexCursor), BigNumber.from(supplyProportionDelta), BigNumber.from(borrowProportionDelta), BigNumber.from(proportionIdle), BigNumber.from(morphoMarketData.reserveFactor));
+    const { newP2PSupplyIndex, newP2PBorrowIndex } = p2pInterestRates.computeP2PIndexes({
+        p2pIndexCursor: BigNumber.from(morphoMarketData.p2pIndexCursor),
+        lastBorrowIndexes: {
+            p2pIndex: BigNumber.from(morphoMarketData.indexes.borrow.p2pIndex),
+            poolIndex: BigNumber.from(aaveIndexes.variableBorrowIndex),
+        },
+        lastSupplyIndexes: {
+            p2pIndex: BigNumber.from(morphoMarketData.indexes.supply.p2pIndex),
+            poolIndex: BigNumber.from(aaveIndexes.liquidityIndex),
+        },
+        poolSupplyIndex: BigNumber.from(newPoolSupplyIndex),
+        poolBorrowIndex: BigNumber.from(newPoolBorrowIndex),
+        deltas: {
+            borrow: {
+                scaledDelta: BigNumber.from(morphoMarketData.deltas.borrow.scaledDelta),
+                scaledP2PTotal: BigNumber.from(morphoMarketData.deltas.borrow.scaledP2PTotal),
+            },
+            supply: {
+                scaledDelta: BigNumber.from(morphoMarketData.deltas.supply.scaledDelta),
+                scaledP2PTotal: BigNumber.from(morphoMarketData.deltas.supply.scaledP2PTotal),
+            },
+        },
+        reserveFactor: BigNumber.from(morphoMarketData.reserveFactor),
+        proportionIdle: BigNumber.from(proportionIdle),
+    });
+    return Object.assign(Object.assign(Object.assign(Object.assign({}, loanInfo), morphoMarketData), aaveIndexes), { p2pBorrowAPY: new Dec(apys.p2pBorrowAPY.toString()).div(100).toString(), p2pSupplyAPY: new Dec(apys.p2pSupplyAPY.toString()).div(100).toString(), morphoBorrowInP2P: assetAmountInEth(morphoAaveMath.indexMul(morphoMarketData.deltas.borrow.scaledP2PTotal, newP2PBorrowIndex).toString(), getAssetInfoByAddress(loanInfo.underlyingTokenAddress).symbol), morphoBorrowOnPool: assetAmountInEth(morphoAaveMath.indexMul(morphoMarketData.scaledMorphoBorrowOnPool, newPoolBorrowIndex).toString(), getAssetInfoByAddress(loanInfo.underlyingTokenAddress).symbol), morphoSupplyInP2P: assetAmountInEth(morphoAaveMath.indexMul(morphoMarketData.deltas.supply.scaledP2PTotal, newP2PSupplyIndex).toString(), getAssetInfoByAddress(loanInfo.underlyingTokenAddress).symbol), morphoSupplyOnPool: assetAmountInEth(morphoAaveMath.indexMul(morphoMarketData.isCollateral ? '0' : morphoMarketData.scaledMorphoSupplyOnPool, newPoolSupplyIndex).toString(), getAssetInfoByAddress(loanInfo.underlyingTokenAddress).symbol) });
+};
+export const getMorphoAaveV3MarketsData = (web3, network, selectedMarket, mainnetWeb3) => __awaiter(void 0, void 0, void 0, function* () {
+    // @ts-ignore
+    const lendingPoolContract = createContractWrapper(web3, network, selectedMarket.lendingPool, selectedMarket.lendingPoolAddress);
+    const _addresses = selectedMarket.assets.map((a) => getAssetInfo(ethToWeth(a)).address);
+    const splitStart = Math.floor(_addresses.length / 2);
+    const loanInfoCallsToSkip = 2; // skipping getFullTokensInfo calls at the start of multicallArray
+    const AaveV3ViewAddress = getConfigContractAddress('AaveV3View', network);
+    const AaveV3ViewAbi = getConfigContractAbi('AaveV3View');
+    const multicallArray = [
+        {
+            target: AaveV3ViewAddress,
+            abiItem: getAbiItem(AaveV3ViewAbi, 'getFullTokensInfo'),
+            params: [selectedMarket.providerAddress, _addresses.slice(0, splitStart)],
+        },
+        {
+            target: AaveV3ViewAddress,
+            abiItem: getAbiItem(AaveV3ViewAbi, 'getFullTokensInfo'),
+            params: [selectedMarket.providerAddress, _addresses.slice(splitStart, _addresses.length)],
+        },
+        ...(_addresses.map((underlyingAddress) => ([{
+                target: lendingPoolContract.options.address,
+                abiItem: getAbiItem(lendingPoolContract.options.jsonInterface, 'market'),
+                params: [underlyingAddress],
+            },
+            {
+                target: selectedMarket.protocolDataAddress,
+                // @ts-ignore
+                abiItem: getAbiItem(getConfigContractAbi(selectedMarket.protocolData), 'getReserveData'),
+                params: [underlyingAddress],
+            }]))).flat(),
+    ];
+    const multicallResponse = yield multicall(multicallArray, web3, network);
+    const loanInfo = [...multicallResponse[0][0], ...multicallResponse[1][0]];
+    const IVariableDebtTokenAbi = getConfigContractAbi('IVariableDebtToken');
+    const IATokenAbi = getConfigContractAbi('IAToken');
+    const scaledBalanceMulticall = [
+        ...loanInfo.map((_, i) => [
+            {
+                target: multicallResponse[(2 * i) + loanInfoCallsToSkip][0].variableDebtToken,
+                abiItem: getAbiItem(IVariableDebtTokenAbi, 'scaledBalanceOf'),
+                params: [lendingPoolContract.options.address],
+            },
+            {
+                target: loanInfo[i].aTokenAddress,
+                abiItem: getAbiItem(IATokenAbi, 'scaledBalanceOf'),
+                params: [lendingPoolContract.options.address],
+            },
+        ]).flat(),
+    ];
+    const [scaledBalanceResponse, morphoRewards] = yield Promise.allSettled([
+        multicall(scaledBalanceMulticall, web3, network),
+        fetch('https://api.morpho.xyz/rewards/emissions'),
+    ]);
+    if (scaledBalanceResponse.status !== 'fulfilled') {
+        throw new Error('Failed to fetch market data.');
+    }
+    const morphoRewardsData = morphoRewards.status === 'fulfilled' ? yield morphoRewards.value.json() : null;
+    const assetsData = yield Promise.all(loanInfo.map((info, i) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a, _b, _c, _d, _e, _f;
+        const morphoMarketData = Object.assign(Object.assign({}, multicallResponse[(2 * i) + loanInfoCallsToSkip][0]), { scaledMorphoBorrowOnPool: scaledBalanceResponse.value[2 * i][0], scaledMorphoSupplyOnPool: scaledBalanceResponse.value[(2 * i) + 1][0] });
+        const marketData = computeMorphoMarketData(info, morphoMarketData, multicallResponse[(2 * i) + (loanInfoCallsToSkip + 1)]);
+        const { symbol, address } = getAssetInfoByAddress(wethToEthByAddress(marketData.underlyingTokenAddress));
+        const data = {
+            symbol,
+            morphoMarketData,
+            hasDelta: new Dec(marketData.p2pSupplyAPY).minus(marketData.p2pBorrowAPY).gte(0.3),
+            eModeCategory: +marketData.emodeCategory,
+            aTokenAddress: marketData.aTokenAddress,
+            underlyingTokenAddress: address,
+            price: new Dec(marketData.price.toString()).div(1e8).toString(),
+            supplyRate: new Dec(marketData.supplyRate.toString()).div(1e25).toString(),
+            supplyRateP2P: marketData.p2pSupplyAPY,
+            borrowRate: new Dec(marketData.borrowRateVariable.toString()).div(1e25).toString(),
+            borrowRateP2P: marketData.p2pBorrowAPY,
+            totalSupply: assetAmountInEth(marketData.totalSupply.toString(), symbol),
+            totalBorrow: assetAmountInEth(marketData.totalBorrow.toString(), symbol),
+            totalSupplyP2P: marketData.morphoSupplyInP2P,
+            totalSupplyPool: marketData.morphoSupplyOnPool,
+            totalBorrowP2P: marketData.morphoBorrowInP2P,
+            totalBorrowPool: marketData.morphoBorrowOnPool,
+            supplyCap: marketData.supplyCap,
+            borrowCap: marketData.borrowCap,
+            usageAsCollateralEnabled: marketData.isCollateral,
+            collateralFactor: marketData.isCollateral ? new Dec(marketData.collateralFactor).div(10000).toString() : '0',
+            liquidationRatio: new Dec(marketData.liquidationRatio).div(10000).toString(),
+            isInactive: !marketData.isActive,
+            isFrozen: marketData.isFrozen,
+            isPaused: marketData.isPaused,
+            canBeBorrowed: !marketData.isFrozen
+                && marketData.borrowingEnabled
+                && !marketData.pauseStatuses.isBorrowPaused
+                && !marketData.pauseStatuses.isDeprecated,
+            canBeSupplied: !marketData.isFrozen
+                && marketData.isCollateral ? !marketData.pauseStatuses.isSupplyCollateralPaused : !marketData.pauseStatuses.isSupplyPaused
+                && !marketData.pauseStatuses.isDeprecated,
+            canBeWithdrawn: marketData.isActive
+                && !marketData.isPaused
+                && marketData.isCollateral ? !marketData.pauseStatuses.isWithdrawCollateralPaused : !marketData.pauseStatuses.isWithdrawPaused,
+            canBePayBacked: marketData.isActive && !marketData.isPaused && !marketData.pauseStatuses.isRepayPaused,
+            reserveFactor: new Dec(marketData.reserveFactor).toString(),
+            pauseStatus: {
+                isSupplyPaused: marketData.pauseStatuses.isSupplyPaused,
+                isSupplyCollateralPaused: marketData.pauseStatuses.isSupplyCollateralPaused,
+                isWithdrawPaused: marketData.pauseStatuses.isWithdrawPaused,
+                isWithdrawCollateralPaused: marketData.pauseStatuses.isWithdrawCollateralPaused,
+                isRepayPaused: marketData.pauseStatuses.isRepayPaused,
+                isBorrowPaused: marketData.pauseStatuses.isBorrowPaused,
+                isDeprecated: marketData.pauseStatuses.isDeprecated,
+                isP2PDisabled: marketData.pauseStatuses.isP2PDisabled,
+            },
+            marketLiquidity: assetAmountInEth(new Dec(marketData.totalSupply.toString())
+                .sub(marketData.totalBorrow.toString())
+                .toString(), symbol),
+            utilization: new Dec(marketData.totalBorrow.toString())
+                .div(new Dec(marketData.totalSupply.toString()))
+                .times(100)
+                .toString(),
+            eModeCategoryData: {
+                label: marketData.label,
+                liquidationBonus: new Dec(marketData.liquidationBonus).div(10000).toString(),
+                liquidationRatio: new Dec(marketData.liquidationThreshold).div(10000).toString(),
+                collateralFactor: new Dec(marketData.ltv).div(10000).toString(),
+                priceSource: marketData.priceSource,
+            },
+            incentiveSupplyToken: 'MORPHO',
+            incentiveBorrowToken: 'MORPHO',
+            incentiveSupplyApy: ((_c = (_a = morphoRewardsData === null || morphoRewardsData === void 0 ? void 0 : morphoRewardsData.markets) === null || _a === void 0 ? void 0 : _a[(_b = marketData.underlyingTokenAddress) === null || _b === void 0 ? void 0 : _b.toLowerCase()]) === null || _c === void 0 ? void 0 : _c.morphoRatePerSecondSupplySide) || '0',
+            incentiveBorrowApy: ((_f = (_d = morphoRewardsData.markets) === null || _d === void 0 ? void 0 : _d[(_e = marketData.underlyingTokenAddress) === null || _e === void 0 ? void 0 : _e.toLowerCase()]) === null || _f === void 0 ? void 0 : _f.morphoRatePerSecondBorrowSide) || '0',
+            totalBorrowVar: '0',
+            borrowRateStable: '0',
+            disabledStableBorrowing: false,
+            isIsolated: false,
+            debtCeilingForIsolationMode: '0',
+            isSiloed: false,
+            isolationModeTotalDebt: '0',
+            assetId: null,
+            isolationModeBorrowingEnabled: false,
+            isFlashLoanEnabled: false,
+        };
+        if (symbol === 'wstETH') {
+            data.incentiveSupplyApy = yield getStETHApr(mainnetWeb3);
+            data.incentiveSupplyToken = symbol;
+        }
+        if (symbol === 'cbETH' && !isLayer2Network(network)) {
+            data.incentiveSupplyApy = yield getCbETHApr(mainnetWeb3);
+            data.incentiveSupplyToken = symbol;
+        }
+        if (symbol === 'rETH') {
+            data.incentiveSupplyApy = yield getREthApr(mainnetWeb3);
+            data.incentiveSupplyToken = symbol;
+        }
+        if (data.symbol === 'sDAI') {
+            data.incentiveSupplyApy = yield getDsrApy(web3, network);
+            data.incentiveSupplyToken = 'sDAI';
+        }
+        return data;
+    })));
+    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 getMorphoAaveV3AccountBalances = (web3, network, block, addressMapping, address) => __awaiter(void 0, void 0, void 0, function* () {
+    let balances = {
+        collateral: {},
+        debt: {},
+    };
+    if (!address) {
+        return balances;
+    }
+    const selectedMarket = MORPHO_AAVE_V3_ETH(network);
+    // @ts-ignore
+    const lendingPoolContract = createContractWrapper(web3, network, selectedMarket.lendingPool, selectedMarket.lendingPoolAddress);
+    const _addresses = selectedMarket.assets.map((a) => getAssetInfo(ethToWeth(a), network).address);
+    const multicallArray = [
+        ...(_addresses.map((underlyingAddress) => ([
+            {
+                target: lendingPoolContract.options.address,
+                abiItem: getAbiItem(lendingPoolContract.options.jsonInterface, 'market'),
+                params: [underlyingAddress],
+            },
+            {
+                target: lendingPoolContract.options.address,
+                abiItem: getAbiItem(lendingPoolContract.options.jsonInterface, 'scaledP2PSupplyBalance'),
+                params: [underlyingAddress, address],
+            },
+            {
+                target: lendingPoolContract.options.address,
+                abiItem: getAbiItem(lendingPoolContract.options.jsonInterface, 'scaledPoolSupplyBalance'),
+                params: [underlyingAddress, address],
+            },
+            {
+                target: lendingPoolContract.options.address,
+                abiItem: getAbiItem(lendingPoolContract.options.jsonInterface, 'scaledCollateralBalance'),
+                params: [underlyingAddress, address],
+            },
+            {
+                target: lendingPoolContract.options.address,
+                abiItem: getAbiItem(lendingPoolContract.options.jsonInterface, 'scaledP2PBorrowBalance'),
+                params: [underlyingAddress, address],
+            },
+            {
+                target: lendingPoolContract.options.address,
+                abiItem: getAbiItem(lendingPoolContract.options.jsonInterface, 'scaledPoolBorrowBalance'),
+                params: [underlyingAddress, address],
+            },
+        ]))).flat(),
+    ];
+    const multicallResponse = yield multicall(multicallArray, web3, network, block);
+    const numberOfMultiCalls = 6;
+    _addresses.forEach((underlyingAddr, i) => {
+        const currentMulticallIndex = numberOfMultiCalls * i;
+        const morphoMarketData = multicallResponse[currentMulticallIndex][0];
+        const { symbol, address: assetAddr } = getAssetInfoByAddress(wethToEthByAddress(underlyingAddr, network), network);
+        const suppliedP2P = morphoAaveMath.indexMul(multicallResponse[currentMulticallIndex + 1][0], morphoMarketData.indexes.supply.p2pIndex).toString();
+        const suppliedPool = morphoAaveMath.indexMul(multicallResponse[currentMulticallIndex + 2][0], morphoMarketData.indexes.supply.poolIndex).toString();
+        const suppliedTotal = new Dec(suppliedP2P).add(suppliedPool).toString();
+        const suppliedCollateral = morphoAaveMath.indexMul(multicallResponse[currentMulticallIndex + 3][0], morphoMarketData.indexes.supply.poolIndex).toString();
+        const supplied = new Dec(suppliedTotal).add(suppliedCollateral).toString();
+        const borrowedP2P = morphoAaveMath.indexMul(multicallResponse[currentMulticallIndex + 4][0], morphoMarketData.indexes.borrow.p2pIndex).toString();
+        const borrowedPool = morphoAaveMath.indexMul(multicallResponse[currentMulticallIndex + 5][0], morphoMarketData.indexes.borrow.poolIndex).toString();
+        const borrowed = new Dec(borrowedP2P).add(borrowedPool).toString();
+        balances = {
+            collateral: Object.assign(Object.assign({}, balances.collateral), { [addressMapping ? assetAddr.toLowerCase() : symbol]: supplied }),
+            debt: Object.assign(Object.assign({}, balances.debt), { [addressMapping ? assetAddr.toLowerCase() : symbol]: borrowed }),
+        };
+    });
+    return balances;
+});
+export const getMorphoAaveV3AccountData = (web3, network, address, assetsData, delegator, selectedMarket) => __awaiter(void 0, void 0, void 0, function* () {
+    var _g;
+    if (!address) {
+        throw new Error('No address provided.');
+    }
+    const eModeCategory = 1; // TODO: morpho v3 pass as arg
+    let payload = Object.assign(Object.assign({}, EMPTY_AAVE_DATA), { usedAssets: {}, // Typescript is bugging out due to JSDocs version of AavePositionData.UsedAssets
+        eModeCategory, minRatio: '100', lastUpdated: Date.now() });
+    // @ts-ignore
+    const lendingPoolContract = createContractWrapper(web3, network, selectedMarket.lendingPool, selectedMarket.lendingPoolAddress);
+    const isManagedBy = delegator && ((_g = lendingPoolContract === null || lendingPoolContract === void 0 ? void 0 : lendingPoolContract.methods) === null || _g === void 0 ? void 0 : _g.isManagedBy)
+        ? yield lendingPoolContract.methods.isManagedBy(address, delegator).call()
+        : null;
+    payload.approvedManager = isManagedBy ? delegator : '';
+    const markets = Object.values(assetsData);
+    // @ts-ignore
+    const marketAddresses = markets.map(m => ethToWethByAddress(m.underlyingTokenAddress));
+    const multicallArray = [
+        ...(marketAddresses.map((marketAddr) => [
+            {
+                target: lendingPoolContract.options.address,
+                abiItem: getAbiItem(lendingPoolContract.options.jsonInterface, 'scaledP2PSupplyBalance'),
+                params: [marketAddr, address],
+            },
+            {
+                target: lendingPoolContract.options.address,
+                abiItem: getAbiItem(lendingPoolContract.options.jsonInterface, 'scaledPoolSupplyBalance'),
+                params: [marketAddr, address],
+            },
+            {
+                target: lendingPoolContract.options.address,
+                abiItem: getAbiItem(lendingPoolContract.options.jsonInterface, 'scaledCollateralBalance'),
+                params: [marketAddr, address],
+            },
+            {
+                target: lendingPoolContract.options.address,
+                abiItem: getAbiItem(lendingPoolContract.options.jsonInterface, 'scaledP2PBorrowBalance'),
+                params: [marketAddr, address],
+            },
+            {
+                target: lendingPoolContract.options.address,
+                abiItem: getAbiItem(lendingPoolContract.options.jsonInterface, 'scaledPoolBorrowBalance'),
+                params: [marketAddr, address],
+            },
+        ]).flat()),
+    ];
+    const multicallResponse = yield multicall(multicallArray, web3, network);
+    markets.forEach((market, i) => {
+        const { symbol } = getAssetInfoByAddress(wethToEthByAddress(market.underlyingTokenAddress));
+        const assetAavePrice = assetsData[symbol].price;
+        const suppliedP2P = assetAmountInEth(morphoAaveMath.indexMul(multicallResponse[i * 5][0], market.morphoMarketData.indexes.supply.p2pIndex), symbol);
+        const suppliedPool = assetAmountInEth(morphoAaveMath.indexMul(multicallResponse[(i * 5) + 1][0], market.morphoMarketData.indexes.supply.poolIndex), symbol);
+        const suppliedTotal = new Dec(suppliedP2P).add(suppliedPool).toString();
+        const suppliedCollateral = assetAmountInEth(morphoAaveMath.indexMul(multicallResponse[(i * 5) + 2][0], market.morphoMarketData.indexes.supply.poolIndex), symbol);
+        const supplied = new Dec(suppliedTotal).add(suppliedCollateral).toString();
+        const suppliedMatched = new Dec(suppliedTotal).eq(0)
+            ? '0'
+            : morphoAaveMath.percentDiv(assetAmountInWei(suppliedP2P, symbol), assetAmountInWei(suppliedTotal, symbol)).div(100).toString();
+        const borrowedP2P = assetAmountInEth(morphoAaveMath.indexMul(multicallResponse[(i * 5) + 3][0], market.morphoMarketData.indexes.borrow.p2pIndex), symbol);
+        const borrowedPool = assetAmountInEth(morphoAaveMath.indexMul(multicallResponse[(i * 5) + 4][0], market.morphoMarketData.indexes.borrow.poolIndex), symbol);
+        const borrowed = new Dec(borrowedP2P).add(borrowedPool).toString();
+        const borrowedMatched = new Dec(borrowed).eq(0)
+            ? '0'
+            : morphoAaveMath.percentDiv(assetAmountInWei(borrowedP2P, symbol), assetAmountInWei(borrowed, symbol)).div(100).toString();
+        const supplyRate = new Dec(new Dec(market.supplyRateP2P).mul(suppliedMatched))
+            .add(new Dec(market.supplyRate).mul(100 - +suppliedMatched)).div(100).toString();
+        const borrowRate = new Dec(new Dec(market.borrowRateP2P).mul(borrowedMatched))
+            .add(new Dec(market.borrowRate).mul(100 - +borrowedMatched)).div(100).toString();
+        if (new Dec(supplied).gt(0) || new Dec(borrowed).gt(0)) {
+            payload.usedAssets[symbol] = {
+                symbol,
+                eModeCategory: market.eModeCategory,
+                supplied,
+                suppliedP2P,
+                suppliedPool,
+                suppliedMatched,
+                borrowed,
+                borrowedP2P,
+                borrowedPool,
+                borrowedMatched,
+                supplyRate,
+                borrowRate,
+                suppliedUsd: new Dec(supplied).mul(assetAavePrice).toString(),
+                suppliedP2PUsd: new Dec(suppliedP2P).mul(assetAavePrice).toString(),
+                suppliedPoolUsd: new Dec(suppliedPool).mul(assetAavePrice).toString(),
+                borrowedUsd: new Dec(borrowed).mul(assetAavePrice).toString(),
+                borrowedP2PUsd: new Dec(borrowedP2P).mul(assetAavePrice).toString(),
+                borrowedPoolUsd: new Dec(borrowedPool).mul(assetAavePrice).toString(),
+                borrowedVariable: borrowed,
+                borrowedUsdVariable: new Dec(borrowed).mul(assetAavePrice).toString(),
+                collateral: new Dec(suppliedCollateral).gt(0),
+                isSupplied: new Dec(supplied).gt(0),
+                isBorrowed: new Dec(borrowed).gt(0),
+                // supplyRate: new Dec(market.experiencedSupplyAPY._hex).div(100).toString(),
+                // borrowRate: new Dec(market.experiencedBorrowAPY._hex).div(100).toString(),
+                limit: '0',
+                interestMode: '',
+                stableBorrowRate: '0',
+                borrowedStable: '0',
+                borrowedUsdStable: '0',
+                stableLimit: '0',
+                variableLimit: '0',
+            };
+        }
+    });
+    payload = Object.assign(Object.assign({}, payload), aaveAnyGetAggregatedPositionData({
+        usedAssets: payload.usedAssets, assetsData, eModeCategory, selectedMarket,
+    }));
+    // Calculate borrow limits per asset
+    Object.values(payload.usedAssets).forEach((item) => {
+        if (item.isBorrowed) {
+            // eslint-disable-next-line no-param-reassign
+            item.limit = calculateBorrowingAssetLimit(item.borrowedUsd, payload.borrowLimitUsd);
+        }
+    });
+    return payload;
+});
+export const getMorphoAaveV3FullPositionData = (web3, network, address, delegator, market, mainnetWeb3) => __awaiter(void 0, void 0, void 0, function* () {
+    const marketData = yield getMorphoAaveV3MarketsData(web3, network, market, mainnetWeb3);
+    const positionData = yield getMorphoAaveV3AccountData(web3, network, address, marketData.assetsData, delegator, market);
+    return positionData;
+});

package/esm/multicall/index.d.ts

@@ -0,0 +1,3 @@
+import Web3 from 'web3';
+import { NetworkNumber } from '../types/common';
+export declare const multicall: (calls: any[], web3: Web3, network?: NetworkNumber, blockNumber?: 'latest' | number) => Promise<any[]>;

package/esm/multicall/index.js

@@ -0,0 +1,27 @@
+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 { UniMulticallContract } from '../contracts';
+import { NetworkNumber } from '../types/common';
+export const multicall = (calls, web3, network = NetworkNumber.Eth, blockNumber = 'latest') => __awaiter(void 0, void 0, void 0, function* () {
+    const multicallContract = UniMulticallContract(web3, network);
+    const formattedCalls = calls.map((call) => {
+        const callData = web3.eth.abi.encodeFunctionCall(call.abiItem, call.params);
+        return { callData, target: call.target || '0x0', gasLimit: call.gasLimit || 1e6 };
+    });
+    const callResult = yield multicallContract.methods.multicall(formattedCalls.filter(item => item.target !== '0x0')).call({}, blockNumber);
+    let formattedResult = [];
+    callResult.returnData.forEach(([success, gasUsed, result], i) => {
+        const formattedRes = result !== '0x'
+            ? web3.eth.abi.decodeParameters(calls[i].abiItem.outputs, result)
+            : undefined;
+        formattedResult = [...formattedResult, formattedRes];
+    });
+    return formattedResult;
+});

package/esm/services/dsrService.d.ts

@@ -0,0 +1,3 @@
+import Web3 from 'web3';
+import { NetworkNumber } from '../types/common';
+export declare const getDsrApy: (web3: Web3, network: NetworkNumber) => Promise<string>;

package/esm/services/dsrService.js

@@ -0,0 +1,21 @@
+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 { SECONDS_PER_YEAR } from '../constants';
+import { PotContract } from '../contracts';
+export const getDsrApy = (web3, network) => __awaiter(void 0, void 0, void 0, function* () {
+    const potContract = PotContract(web3, network);
+    return new Dec(yield potContract.methods.dsr().call())
+        .div(new Dec(1e27))
+        .pow(SECONDS_PER_YEAR)
+        .sub(1)
+        .mul(100)
+        .toString();
+});

package/esm/services/utils.d.ts

@@ -0,0 +1,16 @@
+import { NetworkNumber } from '../types/common';
+export declare const isLayer2Network: (networkId: NetworkNumber) => boolean;
+export declare const addToObjectIf: (condition: any, item: any) => any;
+export declare const ethToWeth: (maybeEth: any) => any;
+export declare const wethToEth: (maybeWeth: any) => any;
+export declare const stEthToWstEth: (maybeStEth: any) => any;
+export declare const wstEthToStEth: (maybeStEth: any) => any;
+export declare const getAbiItem: (abi: any, methodName: string) => any;
+export declare const ADDRESS_REGEX: RegExp;
+export declare const isAddress: (address: string) => boolean;
+export declare const compareAddresses: (addr1?: string, addr2?: string) => boolean;
+export declare const getEthAmountForDecimals: (amount: string | number, decimals: string | number) => string;
+export declare const handleWbtcLegacy: (asset: string) => string;
+export declare const wethToEthByAddress: (maybeWethAddr: string, chainId?: NetworkNumber) => string;
+export declare const ethToWethByAddress: (maybeEthAddr: string, chainId?: NetworkNumber) => string;
+export declare const bytesToString: (hex: string) => string;

package/esm/services/utils.js

@@ -0,0 +1,21 @@
+import Dec from 'decimal.js';
+import { getAssetInfo, getAssetInfoByAddress } from '@defisaver/tokens';
+import { NetworkNumber } from '../types/common';
+export const isLayer2Network = (networkId) => [10, 42161, 8453].includes(+networkId);
+export const addToObjectIf = (condition, item) => (condition ? item : {});
+export const ethToWeth = (maybeEth) => maybeEth === null || maybeEth === void 0 ? void 0 : maybeEth.replace(/^ETH$/, 'WETH');
+export const wethToEth = (maybeWeth) => maybeWeth === null || maybeWeth === void 0 ? void 0 : maybeWeth.replace(/^WETH$/, 'ETH');
+export const stEthToWstEth = (maybeStEth) => maybeStEth === null || maybeStEth === void 0 ? void 0 : maybeStEth.replace(/^stETH$/, 'wstETH');
+export const wstEthToStEth = (maybeStEth) => maybeStEth === null || maybeStEth === void 0 ? void 0 : maybeStEth.replace(/^wstETH$/, 'stETH');
+export const getAbiItem = (abi, methodName) => abi.find((i) => i.name === methodName);
+export const ADDRESS_REGEX = /0x[0-9a-fA-F]{40}/;
+export const isAddress = (address) => typeof address === 'string' && (new RegExp(ADDRESS_REGEX).test(address));
+export const compareAddresses = (addr1 = '', addr2 = '') => addr1.toLowerCase() === addr2.toLowerCase();
+export const getEthAmountForDecimals = (amount, decimals) => new Dec(amount).div(Math.pow(10, +decimals)).toString();
+export const handleWbtcLegacy = (asset) => (asset === 'WBTC Legacy' ? 'WBTC' : asset);
+export const wethToEthByAddress = (maybeWethAddr, chainId = NetworkNumber.Eth) => getAssetInfo(wethToEth(getAssetInfoByAddress(maybeWethAddr, chainId).symbol), chainId).address;
+export const ethToWethByAddress = (maybeEthAddr, chainId = NetworkNumber.Eth) => getAssetInfo(ethToWeth(getAssetInfoByAddress(maybeEthAddr, chainId).symbol), chainId).address;
+export const bytesToString = (hex) => Buffer.from(hex.replace(/^0x/, ''), 'hex')
+    .toString()
+    // eslint-disable-next-line no-control-regex
+    .replace(/\x00/g, '');

package/esm/spark/index.d.ts

@@ -0,0 +1,34 @@
+import Web3 from 'web3';
+import { Blockish, EthAddress, NetworkNumber, PositionBalances } from '../types/common';
+import { EModeCategoryDataMapping, SparkAssetsData, SparkMarketData, SparkMarketsData, SparkPositionData, SparkUsedAssets } from '../types';
+export declare const sparkEmodeCategoriesMapping: (extractedState: {
+    assetsData: SparkAssetsData;
+}, usedAssets: SparkUsedAssets) => {
+    [key: number]: EModeCategoryDataMapping;
+};
+export declare const getSparkMarketsData: (web3: Web3, network: NetworkNumber, selectedMarket: SparkMarketData, mainnetWeb3: Web3) => Promise<SparkMarketsData>;
+export declare const EMPTY_SPARK_DATA: {
+    usedAssets: {};
+    suppliedUsd: string;
+    borrowedUsd: string;
+    borrowLimitUsd: string;
+    leftToBorrowUsd: string;
+    ratio: string;
+    minRatio: string;
+    netApy: string;
+    incentiveUsd: string;
+    totalInterestUsd: string;
+    eModeCategory: number;
+    isInIsolationMode: boolean;
+    isInSiloedMode: boolean;
+    collRatio: string;
+    suppliedCollateralUsd: string;
+    totalSupplied: string;
+    eModeCategories: never[];
+};
+export declare const getSparkAccountBalances: (web3: Web3, network: NetworkNumber, block: Blockish, addressMapping: boolean, address: EthAddress) => Promise<PositionBalances>;
+export declare const getSparkAccountData: (web3: Web3, network: NetworkNumber, address: string, extractedState: {
+    selectedMarket: SparkMarketData;
+    assetsData: SparkAssetsData;
+}) => Promise<SparkPositionData>;
+export declare const getSparkFullPositionData: (web3: Web3, network: NetworkNumber, address: string, market: SparkMarketData, mainnetWeb3: Web3) => Promise<SparkPositionData>;