@defisaver/positions-sdk 0.0.1

package/esm/aaveV3/index.js

@@ -0,0 +1,382 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import Dec from 'decimal.js';
+import { assetAmountInEth, assetAmountInWei, getAssetInfo } from '@defisaver/tokens';
+import { AaveIncentiveDataProviderV3Contract, AaveV3ViewContract, GhoTokenContract, getConfigContractAbi, getConfigContractAddress, } from '../contracts';
+import { addToObjectIf, ethToWeth, getAbiItem, isLayer2Network, wethToEth, } from '../services/utils';
+import { NetworkNumber, } from '../types/common';
+import { calculateNetApy, getStakingApy } from '../staking';
+import { multicall } from '../multicall';
+import { getAssetsBalances } from '../assets';
+import { calculateBorrowingAssetLimit } from '../moneymarket';
+import { aaveAnyGetAggregatedPositionData, aaveV3IsInIsolationMode, aaveV3IsInSiloedMode } from '../helpers/aaveHelpers';
+import { AAVE_V3 } from '../markets/aave';
+export const test = (web3, network) => {
+    const contract = AaveV3ViewContract(web3, 1);
+    return contract.methods.AAVE_REFERRAL_CODE().call();
+};
+export const aaveV3CalculateDiscountRate = (debtBalance, discountTokenBalance, discountRate, minDiscountTokenBalance, minGhoBalanceForDiscount, ghoDiscountedPerDiscountToken) => {
+    if (new Dec(discountTokenBalance).lt(minDiscountTokenBalance) || new Dec(debtBalance).lt(minGhoBalanceForDiscount)) {
+        return '0';
+    }
+    const discountedBalance = new Dec(// wadMul
+    new Dec(discountTokenBalance).mul(ghoDiscountedPerDiscountToken).add(new Dec(1e18).div(2))).div(1e18).toDP(0);
+    if (new Dec(discountedBalance).gte(debtBalance)) {
+        return new Dec(discountRate).div(10000).toDP(4).toString();
+    }
+    return new Dec(discountedBalance)
+        .mul(discountRate)
+        .div(debtBalance)
+        .div(10000)
+        .toDP(4)
+        .toString();
+};
+export const aaveV3EmodeCategoriesMapping = (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 = aaveAnyGetAggregatedPositionData(Object.assign(Object.assign({}, extractedState), { usedAssets, eModeCategory: a.eModeCategory }));
+        const willStayOverCollateralized = new Dec(afterEnteringCategory.ratio).eq(0) || new Dec(afterEnteringCategory.ratio).gt(afterEnteringCategory.liqPercent);
+        const enteringTerms = [borrowingOnlyFromCategory, willStayOverCollateralized];
+        categoriesMapping[a.eModeCategory] = {
+            enteringTerms,
+            canEnterCategory: !enteringTerms.includes(false),
+            id: a.eModeCategory,
+            data: a.eModeCategoryData,
+            assets: a.eModeCategory === 0 ? [] : [...(((_a = categoriesMapping[a.eModeCategory]) === null || _a === void 0 ? void 0 : _a.assets) || []), a.symbol],
+            enabledData: {
+                ratio: afterEnteringCategory.ratio,
+                liqRatio: afterEnteringCategory.liqRatio,
+                liqPercent: afterEnteringCategory.liqPercent,
+                collRatio: afterEnteringCategory.collRatio,
+            },
+        };
+    });
+    return categoriesMapping;
+};
+export function getAaveV3MarketData(web3, network, market, defaultWeb3) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const _addresses = market.assets.map(a => getAssetInfo(ethToWeth(a), network).address);
+        const isL2 = isLayer2Network(network);
+        const loanInfoContract = AaveV3ViewContract(web3, network);
+        const aaveIncentivesContract = AaveIncentiveDataProviderV3Contract(web3, network);
+        const marketAddress = market.providerAddress;
+        const GhoDiscountRateStrategyAddress = getConfigContractAddress('GhoDiscountRateStrategy', NetworkNumber.Eth);
+        const GhoDiscountRateStrategyAbi = getConfigContractAbi('GhoDiscountRateStrategy');
+        const GhoTokenAbi = getConfigContractAbi('GHO');
+        const multicallCallsObject = [
+            {
+                target: GhoDiscountRateStrategyAddress,
+                abiItem: getAbiItem(GhoDiscountRateStrategyAbi, 'GHO_DISCOUNTED_PER_DISCOUNT_TOKEN'),
+                params: [],
+            },
+            {
+                target: GhoDiscountRateStrategyAddress,
+                abiItem: getAbiItem(GhoDiscountRateStrategyAbi, 'DISCOUNT_RATE'),
+                params: [],
+            },
+            {
+                target: GhoDiscountRateStrategyAddress,
+                abiItem: getAbiItem(GhoDiscountRateStrategyAbi, 'MIN_DISCOUNT_TOKEN_BALANCE'),
+                params: [],
+            },
+            {
+                target: GhoDiscountRateStrategyAddress,
+                abiItem: getAbiItem(GhoDiscountRateStrategyAbi, 'MIN_DEBT_TOKEN_BALANCE'),
+                params: [],
+            },
+            {
+                target: getAssetInfo('GHO').address,
+                abiItem: getAbiItem(GhoTokenAbi, 'getFacilitatorsList'),
+                params: [],
+            },
+        ];
+        const ghoContract = GhoTokenContract(web3, network);
+        // eslint-disable-next-line prefer-const
+        let [loanInfo, isBorrowAllowed, multiRes] = yield Promise.all([
+            loanInfoContract.methods.getFullTokensInfo(marketAddress, _addresses).call(),
+            loanInfoContract.methods.isBorrowAllowed(marketAddress).call(),
+            isL2 ? [{ 0: null }, { 0: null }, { 0: null }, { 0: null }, { 0: null }] : multicall(multicallCallsObject, web3, network),
+        ]);
+        isBorrowAllowed = isLayer2Network(network) ? isBorrowAllowed : true;
+        const [{ 0: ghoDiscountedPerDiscountToken }, { 0: discountRate }, { 0: minDiscountTokenBalance }, { 0: minGhoBalanceForDiscount }, { 0: facilitatorsList },] = multiRes;
+        let rewardInfo = null;
+        if (network === 10) {
+            rewardInfo = yield aaveIncentivesContract.methods.getReservesIncentivesData(marketAddress).call();
+            rewardInfo = rewardInfo.reduce((all, _market) => {
+                // eslint-disable-next-line no-param-reassign
+                all[_market.underlyingAsset] = _market;
+                return all;
+            }, {});
+        }
+        const assetsData = yield Promise.all(loanInfo
+            .map((tokenMarket, i) => __awaiter(this, void 0, void 0, function* () {
+            const symbol = market.assets[i];
+            const nativeAsset = symbol === 'GHO';
+            let borrowCap = tokenMarket.borrowCap;
+            let discountRateOnBorrow = '0';
+            if (nativeAsset && facilitatorsList && discountRate && minDiscountTokenBalance && minGhoBalanceForDiscount && ghoDiscountedPerDiscountToken) {
+                borrowCap = assetAmountInEth((yield ghoContract.methods.getFacilitatorBucket(facilitatorsList[0]).call())[0], 'GHO');
+                discountRateOnBorrow = aaveV3CalculateDiscountRate(tokenMarket.totalBorrow.toString(), '3160881469228662060510133', // stkAAVE total supply
+                discountRate, minDiscountTokenBalance, minGhoBalanceForDiscount, ghoDiscountedPerDiscountToken);
+            }
+            return (Object.assign(Object.assign({ nativeAsset }, addToObjectIf(nativeAsset, {
+                discountData: {
+                    ghoDiscountedPerDiscountToken,
+                    discountRate,
+                    minDiscountTokenBalance,
+                    minGhoBalanceForDiscount,
+                },
+            })), { symbol, isIsolated: new Dec(tokenMarket.debtCeilingForIsolationMode).gt(0), debtCeilingForIsolationMode: new Dec(tokenMarket.debtCeilingForIsolationMode).div(100).toString(), isSiloed: tokenMarket.isSiloedForBorrowing, eModeCategory: +tokenMarket.emodeCategory, isolationModeTotalDebt: new Dec(tokenMarket.isolationModeTotalDebt).div(100).toString(), assetId: Number(tokenMarket.assetId), underlyingTokenAddress: tokenMarket.underlyingTokenAddress, supplyRate: new Dec(tokenMarket.supplyRate.toString()).div(1e25).toString(), borrowRate: new Dec(tokenMarket.borrowRateVariable.toString()).div(1e25).toString(), borrowRateDiscounted: nativeAsset ? new Dec(tokenMarket.borrowRateVariable.toString()).div(1e25).mul(1 - parseFloat(discountRateOnBorrow)).toString() : '0', borrowRateStable: new Dec(tokenMarket.borrowRateStable.toString()).div(1e25).toString(), collateralFactor: new Dec(tokenMarket.collateralFactor.toString()).div(10000).toString(), liquidationRatio: new Dec(tokenMarket.liquidationRatio.toString()).div(10000).toString(), marketLiquidity: nativeAsset
+                    ? assetAmountInEth(new Dec(assetAmountInWei(borrowCap.toString(), 'GHO'))
+                        .sub(tokenMarket.totalBorrow.toString())
+                        .toString(), symbol)
+                    : assetAmountInEth(new Dec(tokenMarket.totalSupply.toString())
+                        .sub(tokenMarket.totalBorrow.toString())
+                        .toString(), symbol), utilization: new Dec(tokenMarket.totalBorrow.toString())
+                    .div(new Dec(tokenMarket.totalSupply.toString()))
+                    .times(100)
+                    .toString(), usageAsCollateralEnabled: tokenMarket.usageAsCollateralEnabled, supplyCap: tokenMarket.supplyCap, borrowCap, totalSupply: assetAmountInEth(tokenMarket.totalSupply.toString(), symbol), isInactive: !tokenMarket.isActive, isFrozen: tokenMarket.isFrozen, isPaused: tokenMarket.isPaused, canBeBorrowed: tokenMarket.isActive && !tokenMarket.isPaused && !tokenMarket.isFrozen && tokenMarket.borrowingEnabled && isBorrowAllowed, canBeSupplied: !nativeAsset && tokenMarket.isActive && !tokenMarket.isPaused && !tokenMarket.isFrozen, canBeWithdrawn: tokenMarket.isActive && !tokenMarket.isPaused, canBePayBacked: tokenMarket.isActive && !tokenMarket.isPaused, disabledStableBorrowing: !tokenMarket.stableBorrowRateEnabled, totalBorrow: assetAmountInEth(tokenMarket.totalBorrow.toString(), symbol), totalBorrowVar: assetAmountInEth(tokenMarket.totalBorrowVar.toString(), symbol), price: new Dec(tokenMarket.price.toString()).div(1e8).toString(), isolationModeBorrowingEnabled: tokenMarket.isolationModeBorrowingEnabled, isFlashLoanEnabled: tokenMarket.isFlashLoanEnabled, eModeCategoryData: {
+                    label: tokenMarket.label,
+                    liquidationBonus: new Dec(tokenMarket.liquidationBonus).div(10000).toString(),
+                    liquidationRatio: new Dec(tokenMarket.liquidationThreshold).div(10000).toString(),
+                    collateralFactor: new Dec(tokenMarket.ltv).div(10000).toString(),
+                    priceSource: tokenMarket.priceSource,
+                } }));
+        })));
+        yield Promise.all(assetsData.map((_market) => __awaiter(this, void 0, void 0, function* () {
+            /* eslint-disable no-param-reassign */
+            const rewardForMarket = rewardInfo === null || rewardInfo === void 0 ? void 0 : rewardInfo[_market.underlyingTokenAddress];
+            if (['wstETH', 'cbETH', 'rETH'].includes(_market.symbol)) {
+                if (!isLayer2Network(network) && _market.symbol === 'cbETH')
+                    return;
+                _market.incentiveSupplyApy = yield getStakingApy(_market.symbol, defaultWeb3);
+                _market.incentiveSupplyToken = _market.symbol;
+            }
+            if (_market.canBeBorrowed && _market.incentiveSupplyApy) {
+                _market.incentiveBorrowApy = `-${_market.incentiveSupplyApy}`;
+                _market.incentiveBorrowToken = _market.incentiveSupplyToken;
+            }
+            if (!rewardForMarket)
+                return;
+            const supplyRewardData = rewardForMarket.aIncentiveData.rewardsTokenInformation[0];
+            if (supplyRewardData) {
+                if (+supplyRewardData.emissionEndTimestamp * 1000 < Date.now())
+                    return;
+                _market.incentiveSupplyToken = supplyRewardData.rewardTokenSymbol;
+                const supplyEmissionPerSecond = supplyRewardData.emissionPerSecond;
+                const supplyRewardPrice = new Dec(supplyRewardData.rewardPriceFeed).div(Math.pow(10, +supplyRewardData.priceFeedDecimals)).toString();
+                _market.incentiveSupplyApy = new Dec(supplyEmissionPerSecond).div((Math.pow(10, +supplyRewardData.rewardTokenDecimals)) / 100)
+                    .mul(365 * 24 * 3600)
+                    .mul(supplyRewardPrice)
+                    .div(_market.price)
+                    .div(_market.totalSupply)
+                    .toString();
+            }
+            const borrowRewardData = rewardForMarket.vIncentiveData.rewardsTokenInformation[0];
+            if (borrowRewardData) {
+                if (+borrowRewardData.emissionEndTimestamp * 1000 < Date.now())
+                    return;
+                _market.incentiveBorrowToken = borrowRewardData.rewardTokenSymbol;
+                const supplyEmissionPerSecond = borrowRewardData.emissionPerSecond;
+                const supplyRewardPrice = new Dec(borrowRewardData.rewardPriceFeed).div(Math.pow(10, +borrowRewardData.priceFeedDecimals)).toString();
+                _market.incentiveBorrowApy = new Dec(supplyEmissionPerSecond).div((Math.pow(10, +borrowRewardData.rewardTokenDecimals)) / 100)
+                    .mul(365 * 24 * 3600)
+                    .mul(supplyRewardPrice)
+                    .div(_market.price)
+                    .div(_market.totalBorrowVar)
+                    .toString();
+            }
+            /* eslint-enable no-param-reassign */
+        })));
+        const payload = {};
+        // Sort by market size
+        assetsData
+            .sort((a, b) => {
+            const aMarket = new Dec(a.price).times(a.totalSupply).toString();
+            const bMarket = new Dec(b.price).times(b.totalSupply).toString();
+            return new Dec(bMarket).minus(aMarket).toNumber();
+        })
+            .forEach((assetData, i) => {
+            payload[assetData.symbol] = Object.assign(Object.assign({}, assetData), { sortIndex: i });
+        });
+        return { assetsData: payload };
+    });
+}
+export const EMPTY_AAVE_DATA = {
+    usedAssets: {},
+    suppliedUsd: '0',
+    borrowedUsd: '0',
+    borrowLimitUsd: '0',
+    leftToBorrowUsd: '0',
+    ratio: '0',
+    minRatio: '0',
+    netApy: '0',
+    incentiveUsd: '0',
+    totalInterestUsd: '0',
+    isSubscribedToAutomation: false,
+    automationResubscribeRequired: false,
+    eModeCategory: 0,
+    isInIsolationMode: false,
+    isInSiloedMode: false,
+    totalSupplied: '0',
+    eModeCategories: [],
+    collRatio: '0',
+    suppliedCollateralUsd: '0',
+};
+export const getAaveV3AccountBalances = (web3, network, block, addressMapping, address) => __awaiter(void 0, void 0, void 0, function* () {
+    let balances = {
+        collateral: {},
+        debt: {},
+    };
+    if (!address) {
+        return balances;
+    }
+    const loanInfoContract = AaveV3ViewContract(web3, network, block);
+    const market = AAVE_V3(network);
+    const marketAddress = market.providerAddress;
+    const _addresses = market.assets.map(a => getAssetInfo(ethToWeth(a), network).address);
+    // split addresses in half to avoid gas limit by multicall
+    const middleAddressIndex = Math.floor(_addresses.length / 2);
+    const multicallData = [
+        {
+            target: loanInfoContract.options.address,
+            abiItem: loanInfoContract.options.jsonInterface.find(({ name }) => name === 'getTokenBalances'),
+            params: [marketAddress, address, _addresses.slice(0, middleAddressIndex)],
+        },
+        {
+            target: loanInfoContract.options.address,
+            abiItem: loanInfoContract.options.jsonInterface.find(({ name }) => name === 'getTokenBalances'),
+            params: [marketAddress, address, _addresses.slice(middleAddressIndex, _addresses.length)],
+        },
+    ];
+    const multicallRes = yield multicall(multicallData, web3, network, block);
+    const loanInfo = [...multicallRes[0][0], ...multicallRes[1][0]];
+    loanInfo.forEach((tokenInfo, i) => {
+        const asset = wethToEth(market.assets[i]);
+        balances = {
+            collateral: Object.assign(Object.assign({}, balances.collateral), { [addressMapping ? getAssetInfo(asset, network).address.toLowerCase() : asset]: tokenInfo.balance.toString() }),
+            debt: Object.assign(Object.assign({}, balances.debt), { [addressMapping ? getAssetInfo(asset, network).address.toLowerCase() : asset]: new Dec(tokenInfo.borrowsStable.toString()).add(tokenInfo.borrowsVariable.toString()).toString() }),
+        };
+    });
+    return balances;
+});
+export const getAaveV3AccountData = (web3, network, address, extractedState) => __awaiter(void 0, void 0, void 0, function* () {
+    const { selectedMarket: market, assetsData, } = extractedState;
+    let payload = Object.assign(Object.assign({}, EMPTY_AAVE_DATA), { lastUpdated: Date.now() });
+    if (!address) {
+        // structure that this function returns is complex and dynamic so i didnt want to hardcode it in EMPTY_AAVE_DATA
+        // This case only triggers if user doesnt have proxy and data is refetched once proxy is created
+        // TODO when refactoring aave figure out if this is the best solution.
+        payload.eModeCategories = aaveV3EmodeCategoriesMapping(extractedState, {});
+        return payload;
+    }
+    const isL2 = isLayer2Network(network);
+    const loanInfoContract = AaveV3ViewContract(web3, network);
+    const marketAddress = market.providerAddress;
+    const _addresses = market.assets.map((a) => getAssetInfo(ethToWeth(a), network).address);
+    const middleAddressIndex = Math.floor(_addresses.length / 2); // split addresses in half to avoid gas limit by multicall
+    const LendingPoolAbi = getConfigContractAbi(market.lendingPool);
+    const multicallData = [
+        {
+            target: market.lendingPoolAddress,
+            abiItem: LendingPoolAbi.find(({ name }) => name === 'getUserEMode'),
+            params: [address],
+        },
+        {
+            target: loanInfoContract.options.address,
+            abiItem: 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, { 0: stkAaveBalance }] = yield Promise.all([
+        multicall(multicallData, web3, network),
+        isL2 ? { 0: '0' } : getAssetsBalances(['stkAAVE'], address, network, web3),
+        { 0: '0' },
+    ]);
+    const loanInfo = [...multicallRes[1][0], ...multicallRes[2][0]];
+    const usedAssets = {};
+    loanInfo.map((tokenInfo, i) => __awaiter(void 0, void 0, void 0, function* () {
+        const asset = market.assets[i];
+        const isSupplied = tokenInfo.balance.toString() !== '0';
+        const isBorrowed = tokenInfo.borrowsStable.toString() !== '0' || tokenInfo.borrowsVariable.toString() !== '0';
+        if (!isSupplied && !isBorrowed)
+            return;
+        const supplied = assetAmountInEth(tokenInfo.balance.toString(), asset);
+        const borrowedStable = assetAmountInEth(tokenInfo.borrowsStable.toString(), asset);
+        const borrowedVariable = assetAmountInEth(tokenInfo.borrowsVariable.toString(), asset);
+        const enabledAsCollateral = assetsData[asset].usageAsCollateralEnabled ? tokenInfo.enabledAsCollateral : false;
+        let interestMode;
+        if (borrowedVariable === '0' && borrowedStable !== '0') {
+            interestMode = '1';
+        }
+        else if (borrowedVariable !== '0' && borrowedStable === '0') {
+            interestMode = '2';
+        }
+        else {
+            interestMode = 'both';
+        }
+        if (!usedAssets[asset])
+            usedAssets[asset] = {};
+        const nativeAsset = asset === 'GHO';
+        let discountRateOnBorrow = '0';
+        const borrowed = new Dec(borrowedStable).add(borrowedVariable).toString();
+        if (nativeAsset && new Dec(borrowed).gt(0) && new Dec(stkAaveBalance).gt(0)) {
+            discountRateOnBorrow = aaveV3CalculateDiscountRate(assetAmountInWei(borrowed, 'GHO'), assetAmountInWei(stkAaveBalance, 'stkAAVE'), assetsData[asset].discountData.discountRate, assetsData[asset].discountData.minDiscountTokenBalance, assetsData[asset].discountData.minGhoBalanceForDiscount, assetsData[asset].discountData.ghoDiscountedPerDiscountToken);
+        }
+        usedAssets[asset] = Object.assign(Object.assign({}, usedAssets[asset]), { symbol: asset, supplied, suppliedUsd: new Dec(supplied).mul(assetsData[asset].price).toString(), isSupplied, collateral: enabledAsCollateral, stableBorrowRate: new Dec(tokenInfo.stableBorrowRate).div(1e25).toString(), discountedBorrowRate: new Dec(assetsData[asset].borrowRate).mul(1 - parseFloat(discountRateOnBorrow)).toString(), borrowedStable,
+            borrowedVariable, borrowedUsdStable: new Dec(borrowedStable).mul(assetsData[asset].price).toString(), borrowedUsdVariable: new Dec(borrowedVariable).mul(assetsData[asset].price).toString(), borrowed, borrowedUsd: new Dec(new Dec(borrowedVariable).add(borrowedStable)).mul(assetsData[asset].price).toString(), isBorrowed, eModeCategory: assetsData[asset].eModeCategory, interestMode });
+    }));
+    payload.eModeCategory = +multicallRes[0][0];
+    payload = Object.assign(Object.assign(Object.assign({}, payload), { usedAssets }), aaveAnyGetAggregatedPositionData(Object.assign(Object.assign({}, extractedState), { usedAssets, eModeCategory: payload.eModeCategory })));
+    payload.eModeCategories = aaveV3EmodeCategoriesMapping(extractedState, usedAssets);
+    payload.isInIsolationMode = aaveV3IsInIsolationMode({ usedAssets, assetsData });
+    payload.isInSiloedMode = aaveV3IsInSiloedMode({ usedAssets, assetsData });
+    payload.ratio = payload.borrowedUsd && payload.borrowedUsd !== '0'
+        ? new Dec(payload.borrowLimitUsd).div(payload.borrowedUsd).mul(100).toString()
+        : '0';
+    payload.minRatio = '100';
+    payload.collRatio = payload.borrowedUsd && payload.borrowedUsd !== '0'
+        ? new Dec(payload.suppliedCollateralUsd).div(payload.borrowedUsd).mul(100).toString()
+        : '0';
+    // Calculate borrow limits per asset
+    Object.values(payload.usedAssets).forEach((item) => {
+        if (item.isBorrowed) {
+            // eslint-disable-next-line no-param-reassign
+            item.stableLimit = calculateBorrowingAssetLimit(item.borrowedUsdStable, payload.borrowLimitUsd);
+            // eslint-disable-next-line no-param-reassign
+            item.variableLimit = calculateBorrowingAssetLimit(item.borrowedUsdVariable, payload.borrowLimitUsd);
+            // eslint-disable-next-line no-param-reassign
+            item.limit = calculateBorrowingAssetLimit(item.borrowedUsd, payload.borrowLimitUsd);
+        }
+    });
+    const { netApy, incentiveUsd, totalInterestUsd } = calculateNetApy(usedAssets, assetsData);
+    payload.netApy = netApy;
+    payload.incentiveUsd = incentiveUsd;
+    payload.totalInterestUsd = totalInterestUsd;
+    payload.isSubscribedToAutomation = false;
+    payload.automationResubscribeRequired = false;
+    return payload;
+});
+export const getAaveV3FullPositionData = (web3, network, address, market, mainnetWeb3) => __awaiter(void 0, void 0, void 0, function* () {
+    const marketData = yield getAaveV3MarketData(web3, network, market, mainnetWeb3);
+    const positionData = yield getAaveV3AccountData(web3, network, address, { assetsData: marketData.assetsData, selectedMarket: market });
+    return positionData;
+});

package/esm/assets/index.d.ts

@@ -0,0 +1,4 @@
+import Web3 from 'web3';
+import { EthAddress, NetworkNumber } from '../types/common';
+export declare const getAssetBalance: (asset: string, address: EthAddress, chainId: NetworkNumber, web3: Web3) => Promise<string>;
+export declare const getAssetsBalances: (assets: string[], address: EthAddress, networkId: NetworkNumber, web3: Web3) => Promise<string[]>;

package/esm/assets/index.js

@@ -0,0 +1,49 @@
+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, getAssetInfo } from '@defisaver/tokens';
+import { compareAddresses, isAddress } from '../services/utils';
+import { BalanceScannerContract, getErc20Contract } from '../contracts';
+export const getAssetBalance = (asset, address, chainId, web3) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!address)
+        return '0';
+    // noinspection JSUnusedAssignment
+    let data = '';
+    const isAssetAddress = isAddress(asset);
+    const network = chainId;
+    const isOptimism = network === 10;
+    if (!isOptimism
+        && (asset === 'ETH' || compareAddresses(asset, '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee'))) {
+        data = yield web3.eth.getBalance(address);
+    }
+    else {
+        let _asset = isAssetAddress ? asset : getAssetInfo(asset).address;
+        if (isOptimism && compareAddresses(_asset, '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee')) {
+            _asset = '0xDeadDeAddeAddEAddeadDEaDDEAdDeaDDeAD0000';
+        }
+        const contract = yield getErc20Contract(_asset, web3);
+        data = (yield contract.methods.balanceOf(address).call()).toString();
+    }
+    return isAssetAddress
+        // @ts-ignore
+        ? getEthAmountForDecimals(data, (yield getERC20TokenData(asset)).decimals)
+        : assetAmountInEth(data, asset);
+});
+export const getAssetsBalances = (assets, address, networkId, web3) => __awaiter(void 0, void 0, void 0, function* () {
+    const contract = BalanceScannerContract(web3, networkId);
+    const balancesFromChain = [...yield contract.methods.tokensBalance(address, assets.map(a => getAssetInfo(a, networkId).address)).call()];
+    const balances = balancesFromChain.map((item, i) => (item.success
+        ? assetAmountInEth(web3.utils.hexToNumberString(item.data), assets[i])
+        : '0'));
+    const ethIndex = assets.indexOf('ETH');
+    if (ethIndex !== -1) {
+        balances[ethIndex] = yield getAssetBalance('ETH', address, networkId, web3);
+    }
+    return balances;
+});

package/esm/chickenBonds/index.d.ts

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

package/esm/chickenBonds/index.js

@@ -0,0 +1,20 @@
+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 { getAssetInfo } from '@defisaver/tokens';
+import { ChickenBondsViewContract } from '../contracts';
+export const getChickenBondsAccountBalances = (web3, network, block, addressMapping, bondId) => __awaiter(void 0, void 0, void 0, function* () {
+    const viewContract = ChickenBondsViewContract(web3, network, block);
+    const fullBondInfo = yield viewContract.methods.getBondFullInfo(bondId).call({}, block);
+    return {
+        deposited: {
+            [addressMapping ? getAssetInfo('LUSD', network).address.toLowerCase() : 'LUSD']: fullBondInfo.lusdAmount,
+        },
+    };
+});

package/esm/compoundV2/index.d.ts

@@ -0,0 +1,21 @@
+import Web3 from 'web3';
+import { Blockish, EthAddress, NetworkNumber, PositionBalances } from '../types/common';
+import { CompoundV2AssetsData, CompoundV2MarketsData, CompoundV2PositionData } from '../types';
+export declare const getCompoundV2MarketsData: (web3: Web3, network: NetworkNumber) => Promise<CompoundV2MarketsData>;
+export declare const EMPTY_COMPOUND_DATA: {
+    usedAssets: {};
+    suppliedUsd: string;
+    borrowedUsd: string;
+    borrowLimitUsd: string;
+    leftToBorrowUsd: string;
+    ratio: string;
+    minRatio: string;
+    netApy: string;
+    incentiveUsd: string;
+    totalInterestUsd: string;
+    borrowStableSupplyUnstable: boolean;
+};
+export declare const getCollateralAssetsAddresses: (web3: Web3, network: NetworkNumber, account: string) => Promise<string[]>;
+export declare const getCompoundV2AccountBalances: (web3: Web3, network: NetworkNumber, block: Blockish, addressMapping: boolean, address: EthAddress) => Promise<PositionBalances>;
+export declare const getCompoundV2AccountData: (web3: Web3, network: NetworkNumber, address: string, assetsData: CompoundV2AssetsData) => Promise<CompoundV2PositionData>;
+export declare const getCompoundV2FullPositionData: (web3: Web3, network: NetworkNumber, address: string) => Promise<CompoundV2PositionData>;

package/esm/compoundV2/index.js

@@ -0,0 +1,157 @@
+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, getAssetInfo, getAssetInfoByAddress } from '@defisaver/tokens';
+import Dec from 'decimal.js';
+import { BLOCKS_IN_A_YEAR } from '../constants';
+import { aprToApy } from '../moneymarket';
+import { compareAddresses, handleWbtcLegacy, wethToEth } from '../services/utils';
+import { CompoundLoanInfoContract, ComptrollerContract } from '../contracts';
+import { compoundV2CollateralAssets } from '../markets/compound/marketsAssets';
+import { getCompoundV2AggregatedData } from '../helpers/compoundHelpers';
+const compAddress = '0xc00e94cb662c3520282e6f5717214004a7f26888';
+export const getCompoundV2MarketsData = (web3, network) => __awaiter(void 0, void 0, void 0, function* () {
+    const cAddresses = compoundV2CollateralAssets.map(a => a.address);
+    const loanInfoContract = CompoundLoanInfoContract(web3, network);
+    const loanInfo = yield loanInfoContract.methods.getFullTokensInfo(cAddresses).call();
+    const compPrice = loanInfo.find(m => compareAddresses(m.underlyingTokenAddress, compAddress)).price.toString();
+    const assetsData = loanInfo
+        .map((market, i) => {
+        let symbol = getAssetInfoByAddress(cAddresses[i]).underlyingAsset;
+        let isWbtcLegacy = false;
+        const totalSupply = new Dec(market.totalSupply.toString()).div(1e18).times(market.exchangeRate.toString());
+        const totalBorrow = market.totalBorrow.toString();
+        const borrowCap = market.borrowCap.toString();
+        const compSupplySpeeds = market.compSupplySpeeds.toString();
+        const compBorrowSpeeds = market.compBorrowSpeeds.toString();
+        const assetPrice = market.price.toString();
+        const pricePrecisionDiff = 18 - getAssetInfo(getAssetInfoByAddress(cAddresses[i]).underlyingAsset).decimals;
+        // compSupplySpeeds/compBorrowSpeeds is per block per market (borrow & supply are separate markets)
+        const incentiveSupplyApy = aprToApy((100 * BLOCKS_IN_A_YEAR * +compSupplySpeeds * +compPrice) / +assetPrice / +totalSupply).toString();
+        const incentiveBorrowApy = aprToApy((100 * BLOCKS_IN_A_YEAR * +compBorrowSpeeds * +compPrice) / +assetPrice / +totalBorrow).toString();
+        if (cAddresses[i].toLowerCase() === '0xc11b1268c1a384e55c48c2391d8d480264a3a7f4'.toLowerCase()) {
+            symbol = 'WBTC Legacy';
+            isWbtcLegacy = true;
+        }
+        return {
+            symbol,
+            underlyingTokenAddress: market.underlyingTokenAddress,
+            supplyRate: aprToApy(new Dec(BLOCKS_IN_A_YEAR).times(market.supplyRate.toString()).div(1e16).toString()).toString(),
+            borrowRate: aprToApy(new Dec(BLOCKS_IN_A_YEAR).times(market.borrowRate.toString()).div(1e16).toString()).toString(),
+            incentiveSupplyToken: 'COMP',
+            incentiveBorrowToken: 'COMP',
+            incentiveSupplyApy,
+            incentiveBorrowApy,
+            collateralFactor: new Dec(market.collateralFactor.toString()).div(1e18).toString(),
+            marketLiquidity: assetAmountInEth(market.marketLiquidity.toString(), handleWbtcLegacy(symbol)),
+            utilization: new Dec(market.totalBorrow.toString()).div(totalSupply).times(100).toString(),
+            totalSupply: assetAmountInEth(totalSupply, handleWbtcLegacy(symbol)),
+            totalBorrow: assetAmountInEth(totalBorrow, handleWbtcLegacy(symbol)),
+            exchangeRate: new Dec(market.exchangeRate.toString()).div(1e28).toString(),
+            borrowCap: assetAmountInEth(borrowCap, handleWbtcLegacy(symbol)),
+            canBeBorrowed: market.canBorrow,
+            canBeSupplied: market.canMint,
+            price: new Dec(market.price.toString()).div(Math.pow(10, (18 + pricePrecisionDiff))).toString(),
+        };
+    });
+    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((market, i) => { payload[market.symbol] = Object.assign(Object.assign({}, market), { sortIndex: i }); });
+    return { assetsData: payload };
+});
+export const EMPTY_COMPOUND_DATA = {
+    usedAssets: {},
+    suppliedUsd: '0',
+    borrowedUsd: '0',
+    borrowLimitUsd: '0',
+    leftToBorrowUsd: '0',
+    ratio: '0',
+    minRatio: '0',
+    netApy: '0',
+    incentiveUsd: '0',
+    totalInterestUsd: '0',
+    borrowStableSupplyUnstable: false,
+};
+export const getCollateralAssetsAddresses = (web3, network, account) => __awaiter(void 0, void 0, void 0, function* () {
+    const contract = ComptrollerContract(web3, network);
+    return contract.methods.getAssetsIn(account).call();
+});
+export const getCompoundV2AccountBalances = (web3, network, block, addressMapping, address) => __awaiter(void 0, void 0, void 0, function* () {
+    let balances = {
+        collateral: {},
+        debt: {},
+    };
+    if (!address) {
+        return balances;
+    }
+    const loanInfoContract = CompoundLoanInfoContract(web3, network, block);
+    const loanInfo = yield loanInfoContract.methods.getTokenBalances(address, compoundV2CollateralAssets.map(a => a.address)).call({}, block);
+    loanInfo.balances.forEach((weiAmount, i) => {
+        const asset = wethToEth(compoundV2CollateralAssets[i].symbol === 'cWBTC Legacy'
+            ? `${compoundV2CollateralAssets[i].underlyingAsset} Legacy`
+            : compoundV2CollateralAssets[i].underlyingAsset);
+        balances = {
+            collateral: Object.assign(Object.assign({}, balances.collateral), { [addressMapping ? getAssetInfo(asset, network).address.toLowerCase() : asset]: weiAmount.toString() }),
+        };
+    });
+    loanInfo.borrows.forEach((weiAmount, i) => {
+        const asset = wethToEth(compoundV2CollateralAssets[i].symbol === 'cWBTC Legacy'
+            ? `${compoundV2CollateralAssets[i].underlyingAsset} Legacy`
+            : compoundV2CollateralAssets[i].underlyingAsset);
+        balances = Object.assign(Object.assign({}, balances), { debt: Object.assign(Object.assign({}, balances.debt), { [addressMapping ? getAssetInfo(asset, network).address.toLowerCase() : asset]: weiAmount.toString() }) });
+    });
+    return balances;
+});
+export const getCompoundV2AccountData = (web3, network, address, assetsData) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!address)
+        throw new Error('No address provided');
+    let payload = Object.assign(Object.assign({}, EMPTY_COMPOUND_DATA), { lastUpdated: Date.now() });
+    const loanInfoContract = CompoundLoanInfoContract(web3, network);
+    const loanInfo = yield loanInfoContract.methods.getTokenBalances(address, compoundV2CollateralAssets.map(a => a.address)).call();
+    const collateralAssetsAddresses = yield getCollateralAssetsAddresses(web3, network, address);
+    const usedAssets = {};
+    loanInfo.balances.forEach((weiAmount, i) => {
+        const asset = compoundV2CollateralAssets[i].symbol === 'cWBTC Legacy'
+            ? `${compoundV2CollateralAssets[i].underlyingAsset} Legacy`
+            : compoundV2CollateralAssets[i].underlyingAsset;
+        const amount = assetAmountInEth(weiAmount.toString(), asset);
+        const collateral = !!collateralAssetsAddresses.find(a => compareAddresses(a, compoundV2CollateralAssets[i].address));
+        if (weiAmount.toString() === '0' && !collateral)
+            return;
+        if (!usedAssets[asset])
+            usedAssets[asset] = {};
+        usedAssets[asset] = Object.assign(Object.assign({}, usedAssets[asset]), { symbol: asset, supplied: amount, suppliedUsd: new Dec(amount).mul(assetsData[handleWbtcLegacy(asset)].price).toString(), isSupplied: +amount > 0, collateral });
+    });
+    loanInfo.borrows.forEach((weiAmount, i) => {
+        if (weiAmount.toString() === '0')
+            return;
+        const asset = compoundV2CollateralAssets[i].symbol === 'cWBTC Legacy'
+            ? `${compoundV2CollateralAssets[i].underlyingAsset} Legacy`
+            : compoundV2CollateralAssets[i].underlyingAsset;
+        const amount = assetAmountInEth(weiAmount.toString(), asset);
+        if (!usedAssets[asset])
+            usedAssets[asset] = {};
+        usedAssets[asset] = Object.assign(Object.assign({}, usedAssets[asset]), { symbol: asset, borrowed: amount, borrowedUsd: new Dec(amount).mul(assetsData[handleWbtcLegacy(asset)].price).toString(), isBorrowed: true, collateral: !!usedAssets[asset].collateral });
+    });
+    payload = Object.assign(Object.assign(Object.assign({}, payload), { usedAssets }), getCompoundV2AggregatedData({
+        usedAssets, assetsData,
+    }));
+    return payload;
+});
+export const getCompoundV2FullPositionData = (web3, network, address) => __awaiter(void 0, void 0, void 0, function* () {
+    const marketData = yield getCompoundV2MarketsData(web3, network);
+    const positionData = yield getCompoundV2AccountData(web3, network, address, marketData.assetsData);
+    return positionData;
+});