@defisaver/positions-sdk 0.0.1

package/cjs/types/curveUsd.d.ts

@@ -0,0 +1,101 @@
+import { NetworkNumber } from './common';
+export declare enum CrvUSDVersions {
+    'wstETH' = "wstETH",
+    'WBTC' = "WBTC",
+    'ETH' = "ETH"
+}
+export declare enum CrvUSDStatus {
+    Nonexistant = "Nonexistant",
+    Safe = "Safe",
+    Risk = "Risk",
+    SoftLiquidating = "SoftLiquidating",
+    SoftLiquidated = "SoftLiquidated"
+}
+export interface CrvUSDMarketData {
+    chainIds: NetworkNumber[];
+    label: string;
+    shortLabel: string;
+    value: CrvUSDVersions;
+    collAsset: string;
+    baseAsset: string;
+    controllerAddress: string;
+    ammAddress: string;
+    createCollAssets: string[];
+}
+export interface BandData {
+    id: string;
+    collAmount: string;
+    debtAmount: string;
+    lowPrice: string;
+    highPrice: string;
+}
+export interface UserBandData {
+    id: string;
+    collAmount: string;
+    debtAmount: string;
+    lowPrice: string;
+    highPrice: string;
+    userDebtAmount: string;
+    userCollAmount: string;
+}
+export interface CrvUSDGlobalMarketData {
+    collateral: string;
+    decimals: string;
+    activeBand: string;
+    totalDebt: string;
+    ammPrice: string;
+    basePrice: string;
+    oraclePrice: string;
+    minted: string;
+    redeemed: string;
+    monetaryPolicyRate: string;
+    ammRate: string;
+    minBand: string;
+    maxBand: string;
+    debtCeiling: string;
+    borrowRate: string;
+    futureBorrowRate: string;
+    leftToBorrow: string;
+    bands: BandData[];
+}
+export interface CrvUSDAggregatedPositionData {
+    ratio: string;
+    supplied: string;
+    suppliedUsd: string;
+    borrowedUsd: string;
+    borrowed: string;
+    safetyRatio: string;
+}
+export interface CrvUSDUsedAsset {
+    isSupplied: boolean;
+    supplied: string;
+    suppliedUsd: string;
+    borrowed: string;
+    borrowedUsd: string;
+    isBorrowed: boolean;
+    symbol: string;
+    collateral: boolean;
+    price: string;
+    interestRate?: string;
+}
+export interface CrvUSDUsedAssets {
+    [key: string]: CrvUSDUsedAsset;
+}
+export interface CrvUSDUserData {
+    debtAmount: string;
+    health: string;
+    healthPercent: string;
+    priceHigh: string;
+    priceLow: string;
+    liquidationDiscount: string;
+    numOfBands: string;
+    usedAssets: CrvUSDUsedAssets;
+    status: CrvUSDStatus;
+    ratio: string;
+    supplied: string;
+    suppliedUsd: string;
+    borrowedUsd: string;
+    borrowed: string;
+    safetyRatio: string;
+    userBands: UserBandData[];
+}

package/cjs/types/curveUsd.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CrvUSDStatus = exports.CrvUSDVersions = void 0;
+var CrvUSDVersions;
+(function (CrvUSDVersions) {
+    CrvUSDVersions["wstETH"] = "wstETH";
+    CrvUSDVersions["WBTC"] = "WBTC";
+    CrvUSDVersions["ETH"] = "ETH";
+})(CrvUSDVersions || (exports.CrvUSDVersions = CrvUSDVersions = {}));
+var CrvUSDStatus;
+(function (CrvUSDStatus) {
+    CrvUSDStatus["Nonexistant"] = "Nonexistant";
+    CrvUSDStatus["Safe"] = "Safe";
+    CrvUSDStatus["Risk"] = "Risk";
+    CrvUSDStatus["SoftLiquidating"] = "SoftLiquidating";
+    CrvUSDStatus["SoftLiquidated"] = "SoftLiquidated";
+})(CrvUSDStatus || (exports.CrvUSDStatus = CrvUSDStatus = {}));

package/cjs/types/index.d.ts

@@ -0,0 +1,6 @@
+export * from './aave';
+export * from './compound';
+export * from './spark';
+export * from './curveUsd';
+export * from './liquity';
+export * from './maker';

package/cjs/types/index.js

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

package/cjs/types/liquity.d.ts

@@ -0,0 +1,28 @@
+export declare enum LIQUITY_TROVE_STATUS_ENUM {
+    nonExistent = 0,
+    active = 1,
+    closedByOwner = 2,
+    closedByLiquidation = 3,
+    closedByRedemption = 4
+}
+export declare const LIQUITY_STATUS_MAPPING: {
+    nonExistent: string;
+    active: string;
+    closedByOwner: string;
+    closedByLiquidation: string;
+    closedByRedemption: string;
+};
+export interface LiquityTroveInfo {
+    troveStatus: string;
+    collateral: string;
+    debtInAsset: string;
+    TCRatio: string;
+    recoveryMode: boolean;
+    claimableCollateral: string;
+    borrowingRateWithDecay: string;
+    assetPrice: string;
+    totalETH: string;
+    totalLUSD: string;
+    minCollateralRatio: number;
+    priceForRecovery: string;
+}

package/cjs/types/liquity.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LIQUITY_STATUS_MAPPING = exports.LIQUITY_TROVE_STATUS_ENUM = void 0;
+var LIQUITY_TROVE_STATUS_ENUM;
+(function (LIQUITY_TROVE_STATUS_ENUM) {
+    LIQUITY_TROVE_STATUS_ENUM[LIQUITY_TROVE_STATUS_ENUM["nonExistent"] = 0] = "nonExistent";
+    LIQUITY_TROVE_STATUS_ENUM[LIQUITY_TROVE_STATUS_ENUM["active"] = 1] = "active";
+    LIQUITY_TROVE_STATUS_ENUM[LIQUITY_TROVE_STATUS_ENUM["closedByOwner"] = 2] = "closedByOwner";
+    LIQUITY_TROVE_STATUS_ENUM[LIQUITY_TROVE_STATUS_ENUM["closedByLiquidation"] = 3] = "closedByLiquidation";
+    LIQUITY_TROVE_STATUS_ENUM[LIQUITY_TROVE_STATUS_ENUM["closedByRedemption"] = 4] = "closedByRedemption";
+})(LIQUITY_TROVE_STATUS_ENUM || (exports.LIQUITY_TROVE_STATUS_ENUM = LIQUITY_TROVE_STATUS_ENUM = {}));
+exports.LIQUITY_STATUS_MAPPING = {
+    nonExistent: 'Non existent',
+    active: 'Active',
+    closedByOwner: 'Closed',
+    closedByLiquidation: 'Liquidated',
+    closedByRedemption: 'Redeemed',
+};

package/cjs/types/maker.d.ts

@@ -0,0 +1,49 @@
+import { EthAddress } from './common';
+export interface IlkInfo {
+    ilkLabel: string;
+    currentRate: string;
+    futureRate: string;
+    minDebt: string;
+    globalDebtCeiling: string;
+    globalDebtCurrent: string;
+    assetPrice: string;
+    liqRatio: string;
+    liqPercent: number;
+    stabilityFee: number;
+    liquidationFee: string;
+    creatableDebt: string;
+}
+export interface CdpData {
+    owner: EthAddress;
+    userAddress: EthAddress;
+    id: string;
+    urn: EthAddress;
+    type: string;
+    ilk: string;
+    ilkLabel: string;
+    asset: string;
+    collateral: string;
+    collateralUsd: string;
+    futureDebt: string;
+    debtDai: string;
+    debtUsd: string;
+    debtInAsset: string;
+    debtAssetPrice: string;
+    debtAssetMarketPrice: string;
+    liquidationPrice: string;
+    ratio: string;
+    liqRatio: string;
+    liqPercent: number;
+    assetPrice: string;
+    daiLabel: string;
+    debtAsset: string;
+    unclaimedCollateral: string;
+    debtTooLow: boolean;
+    minDebt: string;
+    stabilityFee: number;
+    creatableDebt: string;
+    globalDebtCeiling: string;
+    globalDebtCurrent: string;
+    liquidationFee: string;
+    lastUpdated: number;
+}

package/cjs/types/maker.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/types/spark.d.ts

@@ -0,0 +1,100 @@
+import { EModeCategoryData, EModeCategoryDataMapping } from './aave';
+import { MMAssetData, MMPositionData, MMUsedAsset, NetworkNumber } from './common';
+export declare enum SparkVersions {
+    SparkV1 = "v1default"
+}
+export interface SparkMarketData {
+    chainIds: NetworkNumber[];
+    label: string;
+    shortLabel: string;
+    url: string;
+    value: SparkVersions;
+    assets: readonly string[];
+    provider: '' | 'SparkPoolAddressesProvider';
+    providerAddress: string;
+    lendingPool: 'SparkLendingPool';
+    lendingPoolAddress: string;
+    protocolData: '' | 'SparkProtocolDataProvider';
+    protocolDataAddress: string;
+    subVersionLabel?: string;
+    protocolName: string;
+    disabled?: boolean;
+}
+export interface SparkAssetData extends MMAssetData {
+    totalBorrowVar: string;
+    sortIndex?: number;
+    usageAsCollateralEnabled: boolean;
+    isIsolated: boolean;
+    eModeCategory: number;
+    eModeCategoryData: EModeCategoryData;
+    liquidationRatio: string;
+}
+export interface SparkAssetsData {
+    [token: string]: SparkAssetData;
+}
+export type SparkMarketsData = {
+    assetsData: SparkAssetsData;
+};
+export interface SparkUsedAsset extends MMUsedAsset {
+    stableBorrowRate: string;
+    borrowedStable: string;
+    borrowedVariable: string;
+    borrowedUsdStable: string;
+    borrowedUsdVariable: string;
+    stableLimit: string;
+    variableLimit: string;
+    limit: string;
+    eModeCategory: number;
+}
+export interface SparkUsedAssets {
+    [token: string]: SparkUsedAsset;
+}
+export interface SparkHelperCommon {
+    usedAssets: SparkUsedAssets;
+    eModeCategory: number;
+    eModeCategories?: {
+        [key: number]: EModeCategoryDataMapping;
+    };
+    assetsData: SparkAssetsData;
+    selectedMarket?: SparkMarketData;
+    network?: NetworkNumber;
+}
+export interface SparkAggregatedPositionData {
+    suppliedUsd: string;
+    suppliedCollateralUsd: string;
+    borrowedUsd: string;
+    borrowLimitUsd: string;
+    liquidationLimitUsd: string;
+    leftToBorrowUsd: string;
+    ratio: string;
+    collRatio: string;
+    netApy: string;
+    incentiveUsd: string;
+    totalInterestUsd: string;
+    liqRatio: string;
+    liqPercent: string;
+    leveragedType: string;
+    leveragedAsset?: string;
+    leveragedLsdAssetRatio?: string;
+    liquidationPrice?: string;
+}
+export interface SparkPositionData extends MMPositionData {
+    ratio: string;
+    minRatio: string;
+    collRatio: string;
+    borrowedUsd: string;
+    borrowLimitUsd: string;
+    suppliedCollateralUsd: string;
+    incentiveUsd: string;
+    totalInterestUsd: string;
+    isSubscribedToAutomation?: boolean;
+    automationResubscribeRequired?: boolean;
+    totalSupplied: string;
+    usedAssets: SparkUsedAssets;
+    eModeCategory: number;
+    isInIsolationMode: boolean;
+    isInSiloedMode: boolean;
+    eModeCategories: {
+        [key: number]: EModeCategoryDataMapping;
+    };
+}

package/cjs/types/spark.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SparkVersions = void 0;
+var SparkVersions;
+(function (SparkVersions) {
+    SparkVersions["SparkV1"] = "v1default";
+})(SparkVersions || (exports.SparkVersions = SparkVersions = {}));

package/esm/aaveV2/index.d.ts

@@ -0,0 +1,9 @@
+import Web3 from 'web3';
+import { Blockish, EthAddress, NetworkNumber, PositionBalances } from '../types/common';
+import { AaveMarketInfo, AaveV2AssetsData, AaveV2PositionData } from '../types';
+export declare const getAaveV2MarketsData: (web3: Web3, network: NetworkNumber, selectedMarket: AaveMarketInfo, ethPrice: string, mainnetWeb3: Web3) => Promise<{
+    assetsData: AaveV2AssetsData;
+}>;
+export declare const getAaveV2AccountBalances: (web3: Web3, network: NetworkNumber, block: Blockish, addressMapping: boolean, address: EthAddress) => Promise<PositionBalances>;
+export declare const getAaveV2AccountData: (web3: Web3, network: NetworkNumber, address: string, assetsData: AaveV2AssetsData, market: AaveMarketInfo) => Promise<AaveV2PositionData>;
+export declare const getAaveV2FullPositionData: (web3: Web3, network: NetworkNumber, address: string, market: AaveMarketInfo, ethPrice: string, mainnetWeb3: Web3) => Promise<AaveV2PositionData>;

package/esm/aaveV2/index.js

@@ -0,0 +1,174 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import Dec from 'decimal.js';
+import { assetAmountInEth, getAssetInfo } from '@defisaver/tokens';
+import { calculateNetApy, getStETHApr } from '../staking';
+import { ethToWeth, wethToEth } from '../services/utils';
+import { AaveLoanInfoV2Contract } from '../contracts';
+import { calculateBorrowingAssetLimit } from '../moneymarket';
+import { EMPTY_AAVE_DATA } from '../aaveV3';
+import { AAVE_V2 } from '../markets/aave';
+import { aaveAnyGetAggregatedPositionData } from '../helpers/aaveHelpers';
+export const getAaveV2MarketsData = (web3, network, selectedMarket, ethPrice, mainnetWeb3) => __awaiter(void 0, void 0, void 0, function* () {
+    const _addresses = selectedMarket.assets.map(a => getAssetInfo(ethToWeth(a)).address);
+    const loanInfoContract = AaveLoanInfoV2Contract(web3, network);
+    const marketAddress = selectedMarket.providerAddress;
+    const loanInfo = yield loanInfoContract.methods.getFullTokensInfo(marketAddress, _addresses).call();
+    const markets = loanInfo
+        .map((market, i) => ({
+        symbol: selectedMarket.assets[i],
+        underlyingTokenAddress: market.underlyingTokenAddress,
+        supplyRate: new Dec(market.supplyRate.toString()).div(1e25).toString(),
+        borrowRate: new Dec(market.borrowRateVariable.toString()).div(1e25).toString(),
+        borrowRateStable: new Dec(market.borrowRateStable.toString()).div(1e25).toString(),
+        collateralFactor: new Dec(market.collateralFactor.toString()).div(10000).toString(),
+        liquidationRatio: new Dec(market.liquidationRatio.toString()).div(10000).toString(),
+        marketLiquidity: assetAmountInEth(new Dec(market.totalSupply.toString())
+            .sub(market.totalBorrow.toString())
+            .toString(), selectedMarket.assets[i]),
+        utilization: new Dec(market.totalBorrow.toString())
+            .div(new Dec(market.totalSupply.toString()))
+            .times(100)
+            .toString(),
+        usageAsCollateralEnabled: market.usageAsCollateralEnabled,
+        supplyCap: '0',
+        borrowCap: '0',
+        totalSupply: assetAmountInEth(market.totalSupply.toString(), selectedMarket.assets[i]),
+        isInactive: !market.isActive,
+        isFrozen: market.isFrozen,
+        canBeBorrowed: market.isActive && market.borrowingEnabled && !market.isFrozen,
+        canBeSupplied: market.isActive && !market.isFrozen,
+        canBeWithdrawn: market.isActive,
+        canBePayBacked: market.isActive,
+        disabledStableBorrowing: !market.stableBorrowRateEnabled,
+        totalBorrow: assetAmountInEth(market.totalBorrow.toString(), selectedMarket.assets[i]),
+        totalBorrowVar: assetAmountInEth(market.totalBorrowVar.toString(), selectedMarket.assets[i]),
+        priceInEth: new Dec(market.price.toString()).div(1e18).toString(),
+        incentiveSupplyToken: 'AAVE',
+        incentiveBorrowToken: 'AAVE',
+        incentiveSupplyApy: '0',
+        price: new Dec(market.price.toString()).div(1e18).mul(ethPrice).toString(),
+    }));
+    const stEthMarket = markets.find(({ symbol }) => symbol === 'stETH');
+    if (stEthMarket) {
+        stEthMarket.incentiveSupplyApy = yield getStETHApr(mainnetWeb3);
+        stEthMarket.incentiveSupplyToken = 'stETH';
+    }
+    const payload = {};
+    // Sort by market size
+    markets
+        .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 getAaveV2AccountBalances = (web3, network, block, addressMapping, address) => __awaiter(void 0, void 0, void 0, function* () {
+    let balances = {
+        collateral: {},
+        debt: {},
+    };
+    if (!address) {
+        return balances;
+    }
+    const market = AAVE_V2;
+    const loanInfoContract = AaveLoanInfoV2Contract(web3, network, block);
+    const marketAddress = market.providerAddress;
+    const _addresses = market.assets.map(a => getAssetInfo(ethToWeth(a), network).address);
+    const loanInfo = yield loanInfoContract.methods.getTokenBalances(marketAddress, address, _addresses).call({}, block);
+    loanInfo.forEach((_tokenInfo, i) => {
+        const asset = wethToEth(market.assets[i]);
+        const tokenInfo = Object.assign({}, _tokenInfo);
+        // known bug: stETH leaves 1 wei on every transfer
+        if (asset === 'stETH' && tokenInfo.balance.toString() === '1') {
+            tokenInfo.balance = '0';
+        }
+        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 getAaveV2AccountData = (web3, network, address, assetsData, market) => __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), { lastUpdated: Date.now() });
+    const loanInfoContract = AaveLoanInfoV2Contract(web3, network);
+    const marketAddress = market.providerAddress;
+    const _addresses = market.assets.map(a => getAssetInfo(ethToWeth(a)).address);
+    const loanInfo = yield loanInfoContract.methods.getTokenBalances(marketAddress, address, _addresses).call();
+    const usedAssets = {};
+    loanInfo.forEach((_tokenInfo, i) => {
+        const asset = market.assets[i];
+        const tokenInfo = Object.assign({}, _tokenInfo);
+        // known bug: stETH leaves 1 wei on every transfer
+        if (asset === 'stETH' && tokenInfo.balance.toString() === '1')
+            tokenInfo.balance = '0';
+        const isSupplied = tokenInfo.balance.toString() !== '0';
+        const isBorrowed = tokenInfo.borrowsStable.toString() !== '0' || tokenInfo.borrowsVariable.toString() !== '0';
+        if (!isSupplied && !isBorrowed)
+            return;
+        const supplied = assetAmountInEth(tokenInfo.balance.toString(), asset);
+        const borrowedStable = assetAmountInEth(tokenInfo.borrowsStable.toString(), asset);
+        const borrowedVariable = assetAmountInEth(tokenInfo.borrowsVariable.toString(), asset);
+        const enabledAsCollateral = assetsData[asset].usageAsCollateralEnabled ? tokenInfo.enabledAsCollateral : false;
+        let interestMode;
+        if (borrowedVariable === '0' && borrowedStable !== '0') {
+            interestMode = '1';
+        }
+        else if (borrowedVariable !== '0' && borrowedStable === '0') {
+            interestMode = '2';
+        }
+        else {
+            interestMode = 'both';
+        }
+        if (!usedAssets[asset])
+            usedAssets[asset] = {};
+        usedAssets[asset] = Object.assign(Object.assign({}, usedAssets[asset]), { symbol: asset, supplied, suppliedUsd: new Dec(supplied).mul(assetsData[asset].price).toString(), isSupplied, collateral: enabledAsCollateral, stableBorrowRate: new Dec(tokenInfo.stableBorrowRate).div(1e25).toString(), borrowedStable,
+            borrowedVariable, borrowedUsdStable: new Dec(borrowedStable).mul(assetsData[asset].price).toString(), borrowedUsdVariable: new Dec(borrowedVariable).mul(assetsData[asset].price).toString(), borrowed: new Dec(borrowedStable).add(borrowedVariable).toString(), borrowedUsd: new Dec(new Dec(borrowedVariable).add(borrowedStable)).mul(assetsData[asset].price).toString(), isBorrowed,
+            interestMode });
+    });
+    payload = Object.assign(Object.assign(Object.assign({}, payload), { usedAssets }), aaveAnyGetAggregatedPositionData({
+        usedAssets, assetsData, eModeCategory: 0, selectedMarket: market,
+    }));
+    payload.ratio = payload.borrowedUsd && payload.borrowedUsd !== '0'
+        ? new Dec(payload.borrowLimitUsd).div(payload.borrowedUsd).mul(100).toString()
+        : '0';
+    payload.minRatio = '100';
+    payload.collRatio = payload.borrowedUsd && payload.borrowedUsd !== '0'
+        ? new Dec(payload.suppliedCollateralUsd).div(payload.borrowedUsd).mul(100).toString()
+        : '0';
+    // Calculate borrow limits per asset
+    Object.values(payload.usedAssets).forEach((item) => {
+        if (item.isBorrowed) {
+            // eslint-disable-next-line no-param-reassign
+            item.stableLimit = calculateBorrowingAssetLimit(item.borrowedUsdStable, payload.borrowLimitUsd);
+            // eslint-disable-next-line no-param-reassign
+            item.variableLimit = calculateBorrowingAssetLimit(item.borrowedUsdVariable, payload.borrowLimitUsd);
+            // eslint-disable-next-line no-param-reassign
+            item.limit = calculateBorrowingAssetLimit(item.borrowedUsd, payload.borrowLimitUsd);
+        }
+    });
+    const { netApy, incentiveUsd, totalInterestUsd } = calculateNetApy(usedAssets, assetsData);
+    payload.netApy = netApy;
+    payload.incentiveUsd = incentiveUsd;
+    payload.totalInterestUsd = totalInterestUsd;
+    return payload;
+});
+export const getAaveV2FullPositionData = (web3, network, address, market, ethPrice, mainnetWeb3) => __awaiter(void 0, void 0, void 0, function* () {
+    const marketData = yield getAaveV2MarketsData(web3, network, market, ethPrice, mainnetWeb3);
+    const positionData = yield getAaveV2AccountData(web3, network, address, marketData.assetsData, market);
+    return positionData;
+});

package/esm/aaveV3/index.d.ts

@@ -0,0 +1,33 @@
+import Web3 from 'web3';
+import { AaveMarketInfo, AaveV3MarketData, AaveV3PositionData, AaveV3UsedAssets, EModeCategoryDataMapping } from '../types/aave';
+import { Blockish, EthAddress, NetworkNumber, PositionBalances } from '../types/common';
+export declare const test: (web3: Web3, network: NetworkNumber) => Promise<string>;
+export declare const aaveV3CalculateDiscountRate: (debtBalance: string, discountTokenBalance: string, discountRate: string, minDiscountTokenBalance: string, minGhoBalanceForDiscount: string, ghoDiscountedPerDiscountToken: string) => string;
+export declare const aaveV3EmodeCategoriesMapping: (extractedState: any, usedAssets: AaveV3UsedAssets) => {
+    [key: number]: EModeCategoryDataMapping;
+};
+export declare function getAaveV3MarketData(web3: Web3, network: NetworkNumber, market: AaveMarketInfo, defaultWeb3: Web3): Promise<AaveV3MarketData>;
+export declare const EMPTY_AAVE_DATA: {
+    usedAssets: {};
+    suppliedUsd: string;
+    borrowedUsd: string;
+    borrowLimitUsd: string;
+    leftToBorrowUsd: string;
+    ratio: string;
+    minRatio: string;
+    netApy: string;
+    incentiveUsd: string;
+    totalInterestUsd: string;
+    isSubscribedToAutomation: boolean;
+    automationResubscribeRequired: boolean;
+    eModeCategory: number;
+    isInIsolationMode: boolean;
+    isInSiloedMode: boolean;
+    totalSupplied: string;
+    eModeCategories: never[];
+    collRatio: string;
+    suppliedCollateralUsd: string;
+};
+export declare const getAaveV3AccountBalances: (web3: Web3, network: NetworkNumber, block: Blockish, addressMapping: boolean, address: EthAddress) => Promise<PositionBalances>;
+export declare const getAaveV3AccountData: (web3: Web3, network: NetworkNumber, address: EthAddress, extractedState: any) => Promise<AaveV3PositionData>;
+export declare const getAaveV3FullPositionData: (web3: Web3, network: NetworkNumber, address: string, market: AaveMarketInfo, mainnetWeb3: Web3) => Promise<AaveV3PositionData>;