@defisaver/positions-sdk 0.0.1

package/esm/markets/compound/index.js

@@ -0,0 +1,78 @@
+import { getConfigContractAddress } from '../../contracts';
+import { CompoundVersions } from '../../types';
+import { NetworkNumber } from '../../types/common';
+import { compoundV2CollateralAssets, v3ETHCollAssets, v3USDbCCollAssets, v3USDCCollAssets, } from './marketsAssets';
+const USDC_BULKER_OPTIONS = {
+    supply: 2,
+    withdraw: 5,
+};
+const STANDARD_BULKER_OPTIONS = {
+    supply: '0x414354494f4e5f535550504c595f4e41544956455f544f4b454e000000000000',
+    withdraw: '0x414354494f4e5f57495448445241575f4e41544956455f544f4b454e00000000',
+};
+export const COMPOUND_V2 = {
+    chainIds: [1],
+    label: 'Compound V2',
+    shortLabel: 'v2',
+    value: CompoundVersions.CompoundV2,
+    baseAsset: '',
+    collAssets: compoundV2CollateralAssets.map(a => a.underlyingAsset),
+    baseMarket: '',
+    baseMarketAddress: '',
+    secondLabel: '',
+    bulkerName: '',
+    bulkerAddress: '',
+    bulkerOptions: { supply: '', withdraw: '' },
+    // icon: SvgAdapter(protocolIcons.compound),
+};
+export const COMPOUND_V3_USDC = (networkId) => ({
+    chainIds: [NetworkNumber.Eth],
+    label: 'Compound V3 - USDC',
+    shortLabel: 'v3',
+    value: CompoundVersions.CompoundV3USDC,
+    baseAsset: 'USDC',
+    collAssets: networkId ? v3USDCCollAssets[networkId] : [],
+    baseMarket: 'cUSDCv3',
+    baseMarketAddress: getConfigContractAddress('cUSDCv3', networkId),
+    secondLabel: 'Market',
+    bulkerName: 'CompV3USDCBulker',
+    bulkerAddress: getConfigContractAddress('CompV3USDCBulker', networkId),
+    bulkerOptions: USDC_BULKER_OPTIONS,
+    // icon: SvgAdapter(protocolIcons.compoundv3),
+});
+export const COMPOUND_V3_ETH = (networkId) => ({
+    chainIds: [NetworkNumber.Eth, NetworkNumber.Base],
+    label: 'Compound V3 - ETH',
+    shortLabel: 'v3',
+    value: CompoundVersions.CompoundV3ETH,
+    baseAsset: 'ETH',
+    collAssets: networkId ? v3ETHCollAssets[networkId] : [],
+    baseMarket: 'cETHv3',
+    baseMarketAddress: getConfigContractAddress('cETHv3', networkId),
+    secondLabel: 'Market',
+    bulkerName: 'CompV3ETHBulker',
+    bulkerAddress: getConfigContractAddress('CompV3ETHBulker', networkId),
+    bulkerOptions: STANDARD_BULKER_OPTIONS,
+    // icon: SvgAdapter(protocolIcons.compoundv3),
+});
+export const COMPOUND_V3_USDBC = (networkId) => ({
+    chainIds: [NetworkNumber.Base],
+    label: 'Compound V3 - USDbC',
+    shortLabel: 'v3',
+    value: CompoundVersions.CompoundV3USDbC,
+    baseAsset: 'USDbC',
+    collAssets: networkId ? v3USDbCCollAssets[networkId] : [],
+    baseMarket: 'cUSDbCv3',
+    baseMarketAddress: getConfigContractAddress('cUSDbCv3', networkId),
+    secondLabel: 'Market',
+    bulkerName: 'CompV3USDbCBulker',
+    bulkerAddress: getConfigContractAddress('CompV3USDbCBulker', networkId),
+    bulkerOptions: STANDARD_BULKER_OPTIONS,
+    // icon: SvgAdapter(protocolIcons.compoundv3),
+});
+export const CompoundMarkets = (networkId) => ({
+    [CompoundVersions.CompoundV2]: COMPOUND_V2,
+    [CompoundVersions.CompoundV3ETH]: COMPOUND_V3_ETH(networkId),
+    [CompoundVersions.CompoundV3USDC]: COMPOUND_V3_USDC(networkId),
+    [CompoundVersions.CompoundV3USDbC]: COMPOUND_V3_USDBC(networkId),
+});

package/esm/markets/compound/marketsAssets.d.ts

@@ -0,0 +1,19 @@
+export declare const compoundV2CollateralAssets: import("@defisaver/tokens/esm/types").AssetData[];
+export declare const v3USDCCollAssets: {
+    readonly 1: readonly ["ETH", "COMP", "WBTC", "UNI", "LINK"];
+    readonly 10: readonly [];
+    readonly 42161: readonly [];
+    readonly 8453: readonly [];
+};
+export declare const v3ETHCollAssets: {
+    readonly 1: readonly ["cbETH", "wstETH"];
+    readonly 10: readonly [];
+    readonly 42161: readonly [];
+    readonly 8453: readonly ["cbETH"];
+};
+export declare const v3USDbCCollAssets: {
+    1: never[];
+    10: never[];
+    42161: never[];
+    8453: string[];
+};

package/esm/markets/compound/marketsAssets.js

@@ -0,0 +1,32 @@
+import { getAssetInfo } from '@defisaver/tokens';
+import { NetworkNumber } from '../../types/common';
+export const compoundV2CollateralAssets = [
+    'cETH', 'cDAI', 'cBAT', 'cZRX', 'cUSDC', 'cWBTC Legacy', 'cWBTC', 'cUSDT',
+    'cTUSD', 'cLINK', 'cUSDP', 'cUNI', 'cCOMP', 'cMKR', 'cSUSHI', 'cAAVE', 'cYFI',
+].map((symbol) => getAssetInfo(symbol));
+export const v3USDCCollAssets = {
+    [NetworkNumber.Eth]: [
+        'ETH', 'COMP', 'WBTC', 'UNI', 'LINK',
+    ],
+    [NetworkNumber.Opt]: [],
+    [NetworkNumber.Arb]: [],
+    [NetworkNumber.Base]: [],
+};
+export const v3ETHCollAssets = {
+    [NetworkNumber.Eth]: [
+        'cbETH', 'wstETH',
+    ],
+    [NetworkNumber.Opt]: [],
+    [NetworkNumber.Arb]: [],
+    [NetworkNumber.Base]: [
+        'cbETH',
+    ],
+};
+export const v3USDbCCollAssets = {
+    [NetworkNumber.Eth]: [],
+    [NetworkNumber.Opt]: [],
+    [NetworkNumber.Arb]: [],
+    [NetworkNumber.Base]: [
+        'ETH', 'cbETH',
+    ],
+};

package/esm/markets/curveUsd/index.d.ts

@@ -0,0 +1,10 @@
+import { CrvUSDMarketData } from '../../types';
+import { NetworkNumber } from '../../types/common';
+export declare const CRVUSD_WSTETH_MARKET: (networkId: NetworkNumber) => CrvUSDMarketData;
+export declare const CRVUSD_ETH_MARKET: (networkId: NetworkNumber) => CrvUSDMarketData;
+export declare const CRVUSD_WBTC_MARKET: (networkId: NetworkNumber) => CrvUSDMarketData;
+export declare const CrvUsdMarkets: (networkId: NetworkNumber) => {
+    readonly wstETH: CrvUSDMarketData;
+    readonly ETH: CrvUSDMarketData;
+    readonly WBTC: CrvUSDMarketData;
+};

package/esm/markets/curveUsd/index.js

@@ -0,0 +1,40 @@
+import { getConfigContractAddress } from '../../contracts';
+import { CrvUSDVersions } from '../../types';
+export const CRVUSD_WSTETH_MARKET = (networkId) => ({
+    chainIds: [1],
+    label: 'wstETH',
+    shortLabel: 'wstETH',
+    value: CrvUSDVersions.wstETH,
+    collAsset: 'wstETH',
+    baseAsset: 'crvUSD',
+    controllerAddress: getConfigContractAddress('crvUSDwstETHController', networkId),
+    ammAddress: getConfigContractAddress('crvUSDwstETHAmm', networkId),
+    createCollAssets: ['wstETH', 'ETH'],
+});
+export const CRVUSD_ETH_MARKET = (networkId) => ({
+    chainIds: [1],
+    label: 'ETH',
+    shortLabel: 'ETH',
+    value: CrvUSDVersions.ETH,
+    collAsset: 'ETH',
+    baseAsset: 'crvUSD',
+    controllerAddress: getConfigContractAddress('crvUSDETHController', networkId),
+    ammAddress: getConfigContractAddress('crvUSDETHAmm', networkId),
+    createCollAssets: ['ETH'],
+});
+export const CRVUSD_WBTC_MARKET = (networkId) => ({
+    chainIds: [1],
+    label: 'WBTC',
+    shortLabel: 'WBTC',
+    value: CrvUSDVersions.WBTC,
+    collAsset: 'WBTC',
+    baseAsset: 'crvUSD',
+    controllerAddress: getConfigContractAddress('crvUSDWBTCController', networkId),
+    ammAddress: getConfigContractAddress('crvUSDWBTCAmm', networkId),
+    createCollAssets: ['WBTC'],
+});
+export const CrvUsdMarkets = (networkId) => ({
+    [CrvUSDVersions.wstETH]: CRVUSD_WSTETH_MARKET(networkId),
+    [CrvUSDVersions.ETH]: CRVUSD_ETH_MARKET(networkId),
+    [CrvUSDVersions.WBTC]: CRVUSD_WBTC_MARKET(networkId),
+});

package/esm/markets/index.d.ts

@@ -0,0 +1,4 @@
+export { AaveMarkets } from './aave';
+export { CompoundMarkets } from './compound';
+export { SparkMarkets } from './spark';
+export { CrvUsdMarkets } from './curveUsd';

package/esm/markets/index.js

@@ -0,0 +1,4 @@
+export { AaveMarkets } from './aave';
+export { CompoundMarkets } from './compound';
+export { SparkMarkets } from './spark';
+export { CrvUsdMarkets } from './curveUsd';

package/esm/markets/spark/index.d.ts

@@ -0,0 +1,9 @@
+import { SparkMarketData } from '../../types';
+import { NetworkNumber } from '../../types/common';
+export declare const sparkEthEmodeId: {
+    readonly 1: 1;
+};
+export declare const SPARK_V1: (networkId?: NetworkNumber) => SparkMarketData;
+export declare const SparkMarkets: (networkId: NetworkNumber) => {
+    readonly v1default: SparkMarketData;
+};

package/esm/markets/spark/index.js

@@ -0,0 +1,26 @@
+import { getConfigContractAddress } from '../../contracts';
+import { SparkVersions } from '../../types';
+import { NetworkNumber } from '../../types/common';
+import { sparkAssetsDefaultMarket } from './marketAssets';
+export const sparkEthEmodeId = {
+    [NetworkNumber.Eth]: 1,
+};
+export const SPARK_V1 = (networkId = NetworkNumber.Eth) => ({
+    chainIds: [1],
+    label: 'Spark',
+    shortLabel: 'v1',
+    value: SparkVersions.SparkV1,
+    url: 'default',
+    assets: networkId ? sparkAssetsDefaultMarket[networkId] : [],
+    provider: 'SparkPoolAddressesProvider',
+    providerAddress: getConfigContractAddress('SparkPoolAddressesProvider', networkId),
+    lendingPool: 'SparkLendingPool',
+    lendingPoolAddress: getConfigContractAddress('SparkLendingPool', networkId),
+    protocolData: 'SparkProtocolDataProvider',
+    protocolDataAddress: getConfigContractAddress('SparkProtocolDataProvider', networkId),
+    // icon: SvgAdapter(protocolIcons.spark),
+    protocolName: 'spark',
+});
+export const SparkMarkets = (networkId) => ({
+    [SparkVersions.SparkV1]: SPARK_V1(networkId),
+});

package/esm/markets/spark/marketAssets.d.ts

@@ -0,0 +1,6 @@
+export declare const sparkAssetsDefaultMarket: {
+    readonly 1: readonly ["ETH", "USDC", "DAI", "GNO", "rETH", "sDAI", "wstETH", "WBTC"];
+    readonly 10: readonly [];
+    readonly 42161: readonly [];
+    readonly 8453: readonly [];
+};

package/esm/markets/spark/marketAssets.js

@@ -0,0 +1,9 @@
+import { NetworkNumber } from '../../types/common';
+export const sparkAssetsDefaultMarket = {
+    [NetworkNumber.Eth]: [
+        'ETH', 'USDC', 'DAI', 'GNO', 'rETH', 'sDAI', 'wstETH', 'WBTC',
+    ],
+    [NetworkNumber.Opt]: [],
+    [NetworkNumber.Arb]: [],
+    [NetworkNumber.Base]: [],
+};

package/esm/moneymarket/index.d.ts

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

package/esm/moneymarket/index.js

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

package/esm/moneymarket/moneymarketCommonService.d.ts

@@ -0,0 +1,12 @@
+import { MMUsedAssets } from '../types/common';
+export declare const getAssetsTotal: (assets: object, filter: any, transform: any) => any;
+export declare const calcLongLiqPrice: (assetPrice: string, borrowedUsd: string, borrowLimitUsd: string) => string;
+export declare const calcShortLiqPrice: (assetPrice: string, borrowedUsd: string, borrowLimitUsd: string) => string;
+export declare const calcLeverageLiqPrice: (leverageType: string, assetPrice: string, borrowedUsd: string, borrowLimitUsd: string) => string;
+export declare const calculateBorrowingAssetLimit: (assetBorrowedUsd: string, borrowLimitUsd: string) => string;
+export declare const STABLE_ASSETS: string[];
+export declare const isLeveragedPos: (usedAssets: MMUsedAssets, dustLimit?: number) => {
+    leveragedType: string;
+    leveragedAsset: string;
+};
+export declare const aprToApy: (interest: string | number, frequency?: number) => number;

package/esm/moneymarket/moneymarketCommonService.js

@@ -0,0 +1,70 @@
+import Dec from 'decimal.js';
+import { BLOCKS_IN_A_YEAR } from '../constants';
+export const getAssetsTotal = (assets, filter, transform) => Object.values(assets)
+    .filter(filter)
+    .map(transform)
+    .reduce((acc, data) => new Dec(acc).add(data), '0')
+    .toString();
+export const calcLongLiqPrice = (assetPrice, borrowedUsd, borrowLimitUsd) => new Dec(assetPrice).mul(borrowedUsd).div(borrowLimitUsd).toString();
+export const calcShortLiqPrice = (assetPrice, borrowedUsd, borrowLimitUsd) => new Dec(assetPrice).div(borrowedUsd).mul(borrowLimitUsd).toString();
+export const calcLeverageLiqPrice = (leverageType, assetPrice, borrowedUsd, borrowLimitUsd) => {
+    if (leverageType === 'short')
+        return calcShortLiqPrice(assetPrice, borrowedUsd, borrowLimitUsd);
+    if (leverageType === 'long' || leverageType === 'lsd-leverage')
+        return calcLongLiqPrice(assetPrice, borrowedUsd, borrowLimitUsd);
+    console.error('invalid leverageType', leverageType);
+    return '0';
+};
+export const calculateBorrowingAssetLimit = (assetBorrowedUsd, borrowLimitUsd) => new Dec(assetBorrowedUsd).div(borrowLimitUsd).times(100).toString();
+export const STABLE_ASSETS = ['DAI', 'USDC', 'USDT', 'TUSD', 'USDP', 'GUSD', 'BUSD', 'SUSD', 'FRAX', 'LUSD', 'USDC.e', 'GHO', 'sDAI'];
+export const isLeveragedPos = (usedAssets, dustLimit = 5) => {
+    let borrowUnstable = 0;
+    let supplyStable = 0;
+    let borrowStable = 0;
+    let supplyUnstable = 0;
+    let longAsset = '';
+    let shortAsset = '';
+    Object.values(usedAssets).forEach(({ symbol, suppliedUsd, borrowedUsd, collateral, }) => {
+        const isSupplied = (+suppliedUsd) > dustLimit; // ignore dust like <limit leftover supply
+        const isBorrowed = (+borrowedUsd) > dustLimit; // ignore dust like <limit leftover supply
+        if (isSupplied && STABLE_ASSETS.includes(symbol) && collateral)
+            supplyStable += 1;
+        if (isBorrowed && STABLE_ASSETS.includes(symbol))
+            borrowStable += 1;
+        if (isBorrowed && !STABLE_ASSETS.includes(symbol)) {
+            borrowUnstable += 1;
+            shortAsset = symbol;
+        }
+        if (isSupplied && !STABLE_ASSETS.includes(symbol) && collateral) {
+            supplyUnstable += 1;
+            longAsset = symbol;
+        }
+    });
+    const isLong = borrowStable > 0 && borrowUnstable === 0 && supplyUnstable === 1 && supplyStable === 0;
+    const isShort = supplyStable > 0 && supplyUnstable === 0 && borrowUnstable === 1 && borrowStable === 0;
+    // lsd -> liquid staking derivative
+    const isLsdLeveraged = supplyUnstable === 1 && borrowUnstable === 1 && shortAsset === 'ETH' && ['stETH', 'wstETH', 'cbETH', 'rETH'].includes(longAsset);
+    if (isLong) {
+        return {
+            leveragedType: 'long',
+            leveragedAsset: longAsset,
+        };
+    }
+    if (isShort) {
+        return {
+            leveragedType: 'short',
+            leveragedAsset: shortAsset,
+        };
+    }
+    if (isLsdLeveraged) {
+        return {
+            leveragedType: 'lsd-leverage',
+            leveragedAsset: longAsset,
+        };
+    }
+    return {
+        leveragedType: '',
+        leveragedAsset: '',
+    };
+};
+export const aprToApy = (interest, frequency = BLOCKS_IN_A_YEAR) => (Math.pow((1 + (+interest / 100) / frequency), frequency) - 1) * 100; // eslint-disable-line

package/esm/morphoAaveV2/index.d.ts

@@ -0,0 +1,7 @@
+import Web3 from 'web3';
+import { Blockish, EthAddress, NetworkNumber, PositionBalances } from '../types/common';
+import { MorphoAaveV2AssetsData, MorphoAaveV2MarketData, MorphoAaveV2PositionData } from '../types';
+export declare const getMorphoAaveV2MarketsData: (web3: Web3, network: NetworkNumber, ethPrice: string, mainnetWeb3: Web3) => Promise<MorphoAaveV2MarketData>;
+export declare const getMorphoAaveV2AccountBalances: (web3: Web3, network: NetworkNumber, block: Blockish, addressMapping: boolean, address: EthAddress) => Promise<PositionBalances>;
+export declare const getMorphoAaveV2AccountData: (web3: Web3, network: NetworkNumber, address: string, assetsData: MorphoAaveV2AssetsData) => Promise<MorphoAaveV2PositionData>;
+export declare const getMorphoAaveV2FullPositionData: (web3: Web3, network: NetworkNumber, address: string, ethPrice: string, mainnetWeb3: Web3) => Promise<MorphoAaveV2PositionData>;

package/esm/morphoAaveV2/index.js

@@ -0,0 +1,199 @@
+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, getAssetInfoByAddress } from '@defisaver/tokens';
+import Dec from 'decimal.js';
+import { wethToEthByAddress } from '../services/utils';
+import { getStETHApr } from '../staking';
+import { MorphoAaveV2ViewContract } from '../contracts';
+import { AaveVersions, } from '../types';
+import { calculateBorrowingAssetLimit } from '../moneymarket';
+import { EMPTY_AAVE_DATA } from '../aaveV3';
+import { aaveAnyGetAggregatedPositionData } from '../helpers/aaveHelpers';
+export const getMorphoAaveV2MarketsData = (web3, network, ethPrice, mainnetWeb3) => __awaiter(void 0, void 0, void 0, function* () {
+    const morphoAaveV2ViewContract = MorphoAaveV2ViewContract(web3, network);
+    const [contractData, morphoRewardsRes] = yield Promise.allSettled([
+        morphoAaveV2ViewContract.methods.getAllMarketsInfo().call(),
+        fetch('https://api.morpho.xyz/rewards/distribution'),
+    ]);
+    if (contractData.status !== 'fulfilled') {
+        throw new Error('Failed to fetch market data.');
+    }
+    const { marketInfo, aaveTokenInfo } = contractData.value;
+    const morphoRewardsData = morphoRewardsRes.status === 'fulfilled' ? yield morphoRewardsRes.value.json() : null;
+    const assetsData = marketInfo.map((market, index) => {
+        var _a;
+        const aaveInfo = aaveTokenInfo[index];
+        const { symbol, address } = getAssetInfoByAddress(wethToEthByAddress(aaveInfo.underlyingTokenAddress));
+        const morphoReward = (_a = morphoRewardsData === null || morphoRewardsData === void 0 ? void 0 : morphoRewardsData.markets) === null || _a === void 0 ? void 0 : _a[aaveInfo.aTokenAddress.toLowerCase()];
+        const supplyRateP2P = new Dec(market.p2pSupplyRate).div(1e25).toString();
+        const borrowRateP2P = new Dec(market.p2pBorrowRate).div(1e25).toString();
+        const hasDelta = new Dec(borrowRateP2P).minus(supplyRateP2P).gte(0.3);
+        return {
+            symbol,
+            hasDelta,
+            aTokenAddress: aaveInfo.aTokenAddress,
+            underlyingTokenAddress: address,
+            priceInEth: new Dec(aaveInfo.price).div(1e18).toString(),
+            price: new Dec(aaveInfo.price).div(1e18).times(ethPrice).toString(),
+            supplyRate: new Dec(market.poolSupplyRate).div(1e25).toString(),
+            supplyRateP2P,
+            borrowRate: new Dec(market.poolBorrowRate).div(1e25).toString(),
+            borrowRateP2P,
+            totalSupply: assetAmountInEth(aaveInfo.totalSupply, symbol),
+            totalBorrow: assetAmountInEth(aaveInfo.totalBorrow, symbol),
+            totalSupplyP2P: assetAmountInEth(market.p2pSupplyAmount, symbol),
+            totalSupplyPool: assetAmountInEth(market.poolSupplyAmount, symbol),
+            totalBorrowP2P: assetAmountInEth(market.p2pBorrowAmount, symbol),
+            totalBorrowPool: assetAmountInEth(market.poolBorrowAmount, symbol),
+            collateralFactor: new Dec(aaveInfo.collateralFactor).div(10000).toString(),
+            liquidationRatio: new Dec(aaveInfo.liquidationRatio).div(10000).toString(),
+            isInactive: !aaveInfo.isActive,
+            isFrozen: aaveInfo.isFrozen,
+            canBeBorrowed: aaveInfo.borrowingEnabled
+                && !aaveInfo.isFrozen
+                && !(market.pauseStatus.isBorrowPaused || market.pauseStatus.isDeprecated),
+            canBeWithdrawn: !market.pauseStatus.isWithdrawPaused,
+            canBePayBacked: !market.pauseStatus.isRepayPaused,
+            canBeSupplied: !aaveInfo.isFrozen && !(market.pauseStatus.isSupplyPaused || market.pauseStatus.isDeprecated),
+            reserveFactor: market.reserveFactor,
+            pauseStatus: market.pauseStatus,
+            incentiveSupplyToken: 'MORPHO',
+            incentiveBorrowToken: 'MORPHO',
+            incentiveSupplyApy: new Dec((morphoReward === null || morphoReward === void 0 ? void 0 : morphoReward.supplyRate) || 0).div(1e18).toString(),
+            incentiveBorrowApy: new Dec((morphoReward === null || morphoReward === void 0 ? void 0 : morphoReward.borrowRate) || 0).div(1e18).toString(),
+            marketLiquidity: assetAmountInEth(new Dec(aaveInfo.totalSupply.toString())
+                .sub(aaveInfo.totalBorrow.toString())
+                .toString(), symbol),
+            utilization: new Dec(aaveInfo.totalBorrow.toString())
+                .div(new Dec(aaveInfo.totalSupply.toString()))
+                .times(100)
+                .toString(),
+            totalBorrowVar: '0',
+            usageAsCollateralEnabled: false,
+            disabledStableBorrowing: false,
+            borrowRateStable: '0',
+            supplyCap: '0',
+            borrowCap: '0',
+        };
+    });
+    const stEthMarket = assetsData.find(({ symbol }) => symbol === 'stETH');
+    if (stEthMarket) {
+        stEthMarket.incentiveSupplyApy = yield getStETHApr(mainnetWeb3);
+        stEthMarket.incentiveSupplyToken = 'stETH';
+    }
+    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 getMorphoAaveV2AccountBalances = (web3, network, block, addressMapping, address) => __awaiter(void 0, void 0, void 0, function* () {
+    let balances = {
+        collateral: {},
+        debt: {},
+    };
+    if (!address) {
+        return balances;
+    }
+    const morphoAaveV2ViewContract = MorphoAaveV2ViewContract(web3, network, block);
+    const { userBalances } = yield morphoAaveV2ViewContract.methods.getUserInfo(address).call({}, block);
+    if (userBalances.length === 0) {
+        return balances;
+    }
+    userBalances.forEach((balance) => {
+        const { symbol, address: assetAddr } = getAssetInfoByAddress(wethToEthByAddress(balance.underlying, network), network);
+        balances = {
+            collateral: Object.assign(Object.assign({}, balances.collateral), { [addressMapping ? assetAddr.toLowerCase() : symbol]: new Dec(balance.supplyBalanceInP2P).add(balance.supplyBalanceOnPool).toString() }),
+            debt: Object.assign(Object.assign({}, balances.debt), { [addressMapping ? assetAddr.toLowerCase() : symbol]: new Dec(balance.borrowBalanceInP2P).add(balance.borrowBalanceOnPool).toString() }),
+        };
+    });
+    return balances;
+});
+export const getMorphoAaveV2AccountData = (web3, network, address, assetsData) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!address) {
+        throw new Error('Address is required.');
+    }
+    let payload = Object.assign(Object.assign({}, EMPTY_AAVE_DATA), { usedAssets: {}, minRatio: '100', lastUpdated: Date.now() });
+    const morphoAaveV2ViewContract = MorphoAaveV2ViewContract(web3, network);
+    const { userBalances } = yield morphoAaveV2ViewContract.methods.getUserInfo(address).call();
+    if (userBalances.length === 0) {
+        return payload;
+    }
+    userBalances.forEach((market) => {
+        const { symbol } = getAssetInfoByAddress(wethToEthByAddress(market.underlying));
+        const suppliedP2P = assetAmountInEth(market.supplyBalanceInP2P, symbol);
+        const suppliedPool = assetAmountInEth(market.supplyBalanceOnPool, symbol);
+        const supplied = new Dec(suppliedP2P).add(suppliedPool).toString();
+        const suppliedMatched = new Dec(suppliedP2P).div(supplied).mul(100).toDP(2)
+            .toString();
+        const assetAavePrice = assetsData[symbol].price;
+        const borrowedP2P = assetAmountInEth(market.borrowBalanceInP2P, symbol);
+        const borrowedPool = assetAmountInEth(market.borrowBalanceOnPool, symbol);
+        const borrowed = new Dec(borrowedP2P).add(borrowedPool).toString();
+        const borrowedMatched = new Dec(borrowedP2P).div(borrowed).mul(100).toDP(2)
+            .toString();
+        const borrowedUsd = new Dec(borrowed).mul(assetAavePrice).toString();
+        payload.usedAssets[symbol] = {
+            symbol,
+            supplied,
+            suppliedP2P,
+            suppliedPool,
+            suppliedMatched,
+            borrowed,
+            borrowedP2P,
+            borrowedPool,
+            borrowedMatched,
+            suppliedUsd: new Dec(supplied).mul(assetAavePrice).toString(),
+            suppliedP2PUsd: new Dec(suppliedP2P).mul(assetAavePrice).toString(),
+            suppliedPoolUsd: new Dec(suppliedPool).mul(assetAavePrice).toString(),
+            borrowedUsd,
+            borrowedP2PUsd: new Dec(borrowedP2P).mul(assetAavePrice).toString(),
+            borrowedPoolUsd: new Dec(borrowedPool).mul(assetAavePrice).toString(),
+            borrowedVariable: borrowed,
+            borrowedUsdVariable: borrowedUsd,
+            isSupplied: new Dec(supplied).gt(0),
+            isBorrowed: new Dec(borrowed).gt(0),
+            supplyRate: new Dec(market.userSupplyRate).div(1e25).toString(),
+            borrowRate: new Dec(market.userBorrowRate).div(1e25).toString(),
+            limit: '0',
+            collateral: true,
+            eModeCategory: 0,
+            interestMode: '',
+            stableBorrowRate: '0',
+            borrowedStable: '0',
+            borrowedUsdStable: '0',
+            stableLimit: '0',
+            variableLimit: '0',
+        };
+    });
+    payload = Object.assign(Object.assign({}, payload), aaveAnyGetAggregatedPositionData({
+        usedAssets: payload.usedAssets, assetsData, eModeCategory: 0, selectedMarket: { value: AaveVersions.MorphoAaveV2 },
+    }));
+    // 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 getMorphoAaveV2FullPositionData = (web3, network, address, ethPrice, mainnetWeb3) => __awaiter(void 0, void 0, void 0, function* () {
+    const marketData = yield getMorphoAaveV2MarketsData(web3, network, ethPrice, mainnetWeb3);
+    const positionData = yield getMorphoAaveV2AccountData(web3, network, address, marketData.assetsData);
+    return positionData;
+});

package/esm/morphoAaveV3/index.d.ts

@@ -0,0 +1,7 @@
+import Web3 from 'web3';
+import { Blockish, EthAddress, NetworkNumber, PositionBalances } from '../types/common';
+import { MorphoAaveV3AssetsData, MorphoAaveV3MarketData, MorphoAaveV3MarketInfo, MorphoAaveV3PositionData } from '../types';
+export declare const getMorphoAaveV3MarketsData: (web3: Web3, network: NetworkNumber, selectedMarket: MorphoAaveV3MarketInfo, mainnetWeb3: Web3) => Promise<MorphoAaveV3MarketData>;
+export declare const getMorphoAaveV3AccountBalances: (web3: Web3, network: NetworkNumber, block: Blockish, addressMapping: boolean, address: EthAddress) => Promise<PositionBalances>;
+export declare const getMorphoAaveV3AccountData: (web3: Web3, network: NetworkNumber, address: string, assetsData: MorphoAaveV3AssetsData, delegator: string, selectedMarket: MorphoAaveV3MarketInfo) => Promise<MorphoAaveV3PositionData>;
+export declare const getMorphoAaveV3FullPositionData: (web3: Web3, network: NetworkNumber, address: string, delegator: string, market: MorphoAaveV3MarketInfo, mainnetWeb3: Web3) => Promise<MorphoAaveV3PositionData>;