@defisaver/positions-sdk 0.0.1

package/esm/constants/index.d.ts

@@ -0,0 +1,4 @@
+export declare const SECONDS_PER_YEAR: number;
+export declare const AVG_BLOCK_TIME = 12;
+export declare const BLOCKS_IN_A_YEAR: number;
+export declare const ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";

package/esm/constants/index.js

@@ -0,0 +1,4 @@
+export const SECONDS_PER_YEAR = 365 * 24 * 60 * 60;
+export const AVG_BLOCK_TIME = 12;
+export const BLOCKS_IN_A_YEAR = SECONDS_PER_YEAR / AVG_BLOCK_TIME;
+export const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';

package/esm/contracts.d.ts

@@ -0,0 +1,40 @@
+import Web3 from 'web3';
+import configRaw from './config/contracts';
+import { BaseContract } from './types/contracts/generated/types';
+import * as ContractTypes from './types/contracts/generated';
+import { Blockish, NetworkNumber } from './types/common';
+export type ConfigKey = keyof typeof configRaw;
+export declare const getConfigContractAddress: (name: ConfigKey, network: NetworkNumber, block?: Blockish) => string;
+export declare const getConfigContractAbi: (name: ConfigKey) => any[];
+export declare const getErc20Contract: (address: string, web3: Web3) => import("web3-eth-contract").Contract;
+export declare const createContractWrapper: (web3: Web3, network: NetworkNumber, name: ConfigKey, _address?: string, block?: Blockish) => BaseContract;
+export declare const UniMulticallContract: (web3: Web3, network: NetworkNumber, block?: Blockish) => ContractTypes.UniMulticall;
+export declare const AaveV3ViewContract: (web3: Web3, network: NetworkNumber, block?: Blockish) => ContractTypes.AaveV3View;
+export declare const AaveIncentiveDataProviderV3Contract: (web3: Web3, network: NetworkNumber, block?: Blockish) => ContractTypes.AaveUiIncentiveDataProviderV3;
+export declare const GhoTokenContract: (web3: Web3, network: NetworkNumber, block?: Blockish) => ContractTypes.GHO;
+export declare const LidoContract: (web3: Web3, network: NetworkNumber, block?: Blockish) => ContractTypes.Lido;
+export declare const CbEthContract: (web3: Web3, network: NetworkNumber, block?: Blockish) => ContractTypes.CbEth;
+export declare const REthContract: (web3: Web3, network: NetworkNumber, block?: Blockish) => ContractTypes.REth;
+export declare const BalanceScannerContract: (web3: Web3, network: NetworkNumber, block?: Blockish) => ContractTypes.BalanceScanner;
+export declare const CompV3ViewContract: (web3: Web3, network: NetworkNumber, block?: Blockish) => ContractTypes.CompV3View;
+export declare const wstETHContract: (web3: Web3, network: NetworkNumber, block?: Blockish) => ContractTypes.WstETH;
+export declare const AaveLoanInfoV2Contract: (web3: Web3, network: NetworkNumber, block?: Blockish) => ContractTypes.AaveLoanInfoV2;
+export declare const CompoundLoanInfoContract: (web3: Web3, network: NetworkNumber, block?: Blockish) => ContractTypes.CompoundLoanInfo;
+export declare const ComptrollerContract: (web3: Web3, network: NetworkNumber, block?: Blockish) => ContractTypes.Comptroller;
+export declare const PotContract: (web3: Web3, network: NetworkNumber, block?: Blockish) => ContractTypes.Pot;
+export declare const MorphoAaveV2ViewContract: (web3: Web3, network: NetworkNumber, block?: Blockish) => ContractTypes.MorphoAaveV2View;
+export declare const SparkIncentiveDataProviderContract: (web3: Web3, network: NetworkNumber, block?: Blockish) => ContractTypes.SparkIncentiveDataProvider;
+export declare const SparkViewContract: (web3: Web3, network: NetworkNumber, block?: Blockish) => ContractTypes.SparkView;
+export declare const CrvUSDViewContract: (web3: Web3, network: NetworkNumber, block?: Blockish) => ContractTypes.CrvUSDView;
+export declare const CrvUSDFactoryContract: (web3: Web3, network: NetworkNumber, block?: Blockish) => ContractTypes.CrvUSDFactory;
+export declare const LiquityViewContract: (web3: Web3, network: NetworkNumber, block?: Blockish) => ContractTypes.LiquityView;
+export declare const LiquityCollSurplusPoolContract: (web3: Web3, network: NetworkNumber, block?: Blockish) => ContractTypes.CollSurplusPool;
+export declare const LiquityTroveManagerContract: (web3: Web3, network: NetworkNumber, block?: Blockish) => ContractTypes.TroveManager;
+export declare const LiquityPriceFeedContract: (web3: Web3, network: NetworkNumber, block?: Blockish) => ContractTypes.PriceFeed;
+export declare const LiquityActivePoolContract: (web3: Web3, network: NetworkNumber, block?: Blockish) => ContractTypes.LiquityActivePool;
+export declare const McdViewContract: (web3: Web3, network: NetworkNumber, block?: Blockish) => ContractTypes.McdView;
+export declare const McdSpotterContract: (web3: Web3, network: NetworkNumber, block?: Blockish) => ContractTypes.McdSpotter;
+export declare const McdDogContract: (web3: Web3, network: NetworkNumber, block?: Blockish) => ContractTypes.McdDog;
+export declare const McdJugContract: (web3: Web3, network: NetworkNumber, block?: Blockish) => ContractTypes.McdJug;
+export declare const McdVatContract: (web3: Web3, network: NetworkNumber, block?: Blockish) => ContractTypes.McdVat;
+export declare const ChickenBondsViewContract: (web3: Web3, network: NetworkNumber, block?: Blockish) => ContractTypes.ChickenBondsView;

package/esm/contracts.js

@@ -0,0 +1,55 @@
+import configRaw from './config/contracts';
+const contractConfig = configRaw;
+export const getConfigContractAddress = (name, network, block) => {
+    const networkData = contractConfig[name].networks[network];
+    const latestAddress = (networkData === null || networkData === void 0 ? void 0 : networkData.address) || '';
+    if (block && block !== 'latest') {
+        if (block >= ((networkData === null || networkData === void 0 ? void 0 : networkData.createdBlock) || 0)) {
+            return latestAddress;
+        }
+        const oldVersions = (networkData === null || networkData === void 0 ? void 0 : networkData.oldVersions) || {};
+        for (const [createdBlock, address] of Object.entries(oldVersions).reverse()) {
+            if (block >= Number(createdBlock)) {
+                return address;
+            }
+        }
+    }
+    return latestAddress;
+};
+export const getConfigContractAbi = (name) => contractConfig[name].abi;
+const createContractFromConfigFunc = (name, _address) => (web3, network, block) => {
+    const address = _address || getConfigContractAddress(name, network, block);
+    return new web3.eth.Contract(contractConfig[name].abi, address);
+};
+export const getErc20Contract = (address, web3) => (new web3.eth.Contract(getConfigContractAbi('Erc20'), address));
+export const createContractWrapper = (web3, network, name, _address, block) => (createContractFromConfigFunc(name, _address)(web3, network, block));
+export const UniMulticallContract = createContractFromConfigFunc('UniMulticall');
+export const AaveV3ViewContract = createContractFromConfigFunc('AaveV3View');
+export const AaveIncentiveDataProviderV3Contract = createContractFromConfigFunc('AaveUiIncentiveDataProviderV3');
+export const GhoTokenContract = createContractFromConfigFunc('GHO');
+export const LidoContract = createContractFromConfigFunc('Lido');
+export const CbEthContract = createContractFromConfigFunc('CbEth');
+export const REthContract = createContractFromConfigFunc('REth');
+export const BalanceScannerContract = createContractFromConfigFunc('BalanceScanner');
+export const CompV3ViewContract = createContractFromConfigFunc('CompV3View');
+export const wstETHContract = createContractFromConfigFunc('wstETH');
+export const AaveLoanInfoV2Contract = createContractFromConfigFunc('AaveLoanInfoV2');
+export const CompoundLoanInfoContract = createContractFromConfigFunc('CompoundLoanInfo');
+export const ComptrollerContract = createContractFromConfigFunc('Comptroller');
+export const PotContract = createContractFromConfigFunc('Pot');
+export const MorphoAaveV2ViewContract = createContractFromConfigFunc('MorphoAaveV2View');
+export const SparkIncentiveDataProviderContract = createContractFromConfigFunc('SparkIncentiveDataProvider');
+export const SparkViewContract = createContractFromConfigFunc('SparkView');
+export const CrvUSDViewContract = createContractFromConfigFunc('crvUSDView');
+export const CrvUSDFactoryContract = createContractFromConfigFunc('crvUSDFactory');
+export const LiquityViewContract = createContractFromConfigFunc('LiquityView');
+export const LiquityCollSurplusPoolContract = createContractFromConfigFunc('CollSurplusPool');
+export const LiquityTroveManagerContract = createContractFromConfigFunc('TroveManager');
+export const LiquityPriceFeedContract = createContractFromConfigFunc('PriceFeed');
+export const LiquityActivePoolContract = createContractFromConfigFunc('LiquityActivePool');
+export const McdViewContract = createContractFromConfigFunc('McdView');
+export const McdSpotterContract = createContractFromConfigFunc('McdSpotter');
+export const McdDogContract = createContractFromConfigFunc('McdDog');
+export const McdJugContract = createContractFromConfigFunc('McdJug');
+export const McdVatContract = createContractFromConfigFunc('McdVat');
+export const ChickenBondsViewContract = createContractFromConfigFunc('ChickenBondsView');

package/esm/curveUsd/index.d.ts

@@ -0,0 +1,7 @@
+import Web3 from 'web3';
+import { CrvUSDGlobalMarketData, CrvUSDMarketData, CrvUSDUserData, CrvUSDVersions } from '../types';
+import { Blockish, EthAddress, NetworkNumber, PositionBalances } from '../types/common';
+export declare const getCurveUsdGlobalData: (web3: Web3, network: NetworkNumber, selectedMarket: CrvUSDMarketData) => Promise<CrvUSDGlobalMarketData>;
+export declare const getCrvUsdAccountBalances: (web3: Web3, network: NetworkNumber, block: Blockish, addressMapping: boolean, address: EthAddress, crvUsdVersion: CrvUSDVersions) => Promise<PositionBalances>;
+export declare const getCurveUsdUserData: (web3: Web3, network: NetworkNumber, address: string, selectedMarket: CrvUSDMarketData, activeBand: string) => Promise<CrvUSDUserData>;
+export declare const getCurveUsdFullPositionData: (web3: Web3, network: NetworkNumber, address: string, selectedMarket: CrvUSDMarketData) => Promise<CrvUSDUserData>;

package/esm/curveUsd/index.js

@@ -0,0 +1,189 @@
+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 { CrvUSDStatus, } from '../types';
+import { multicall } from '../multicall';
+import { NetworkNumber, } from '../types/common';
+import { CrvUSDFactoryContract, CrvUSDViewContract } from '../contracts';
+import { getCrvUsdAggregatedData } from '../helpers/curveUsdHelpers';
+import { CrvUsdMarkets } from '../markets';
+import { wethToEth } from '../services/utils';
+const getAndFormatBands = (web3, network, selectedMarket, _minBand, _maxBand) => __awaiter(void 0, void 0, void 0, function* () {
+    const contract = CrvUSDViewContract(web3, network);
+    const minBand = parseInt(_minBand, 10);
+    const maxBand = parseInt(_maxBand, 10);
+    const pivots = [];
+    // getBandsData uses a lot of gas to get all of the bands at once, so we use pagination and fetch 200 bands at a time
+    let i = minBand;
+    while (i < maxBand) {
+        i += 200;
+        if (i > maxBand) {
+            pivots.push(maxBand);
+        }
+        else {
+            pivots.push(i);
+        }
+    }
+    const bandsData = (yield Promise.all(pivots.map((pivot, index) => __awaiter(void 0, void 0, void 0, function* () {
+        let start = 0;
+        if (index === 0) {
+            start = minBand;
+        }
+        else {
+            start = pivots[index - 1] + 1;
+        }
+        // @ts-ignore
+        const pivotedBandsData = yield contract.methods.getBandsData(selectedMarket.controllerAddress, start, pivot).call();
+        return pivotedBandsData;
+    })))).flat();
+    return bandsData.map((band) => ({
+        id: band.id,
+        collAmount: assetAmountInEth(band.collAmount),
+        debtAmount: assetAmountInEth(band.debtAmount),
+        lowPrice: assetAmountInEth(band.lowPrice),
+        highPrice: assetAmountInEth(band.highPrice),
+    }));
+});
+export const getCurveUsdGlobalData = (web3, network, selectedMarket) => __awaiter(void 0, void 0, void 0, function* () {
+    const contract = CrvUSDViewContract(web3, network);
+    const factoryContract = CrvUSDFactoryContract(web3, network);
+    const collAsset = selectedMarket.collAsset;
+    const debtAsset = selectedMarket.baseAsset;
+    const multicallData = [
+        {
+            target: factoryContract.options.address,
+            abiItem: factoryContract.options.jsonInterface.find(({ name }) => name === 'debt_ceiling'),
+            params: [selectedMarket.controllerAddress],
+        },
+        {
+            target: factoryContract.options.address,
+            abiItem: factoryContract.options.jsonInterface.find(({ name }) => name === 'total_debt'),
+            params: [],
+        },
+        {
+            target: contract.options.address,
+            abiItem: contract.options.jsonInterface.find(({ name }) => name === 'globalData'),
+            params: [selectedMarket.controllerAddress],
+        },
+    ];
+    const multiRes = yield multicall(multicallData, web3, network);
+    const data = multiRes[2][0];
+    const debtCeiling = assetAmountInEth(multiRes[0][0], debtAsset);
+    // all prices are in 18 decimals
+    const totalDebt = assetAmountInEth(data.totalDebt, debtAsset);
+    const ammPrice = assetAmountInEth(data.ammPrice, debtAsset);
+    const rate = assetAmountInEth(data.ammRate);
+    const futureRate = assetAmountInEth(data.monetaryPolicyRate);
+    const exponentRate = new Dec(rate).mul(365).mul(86400);
+    const exponentFutureRate = new Dec(futureRate).mul(365).mul(86400);
+    const borrowRate = new Dec(new Dec(2.718281828459).pow(exponentRate).minus(1)).mul(100)
+        .toString();
+    const futureBorrowRate = new Dec(new Dec(2.718281828459).pow(exponentFutureRate).minus(1)).mul(100)
+        .toString();
+    const bandsData = yield getAndFormatBands(web3, network, selectedMarket, data.minBand, data.maxBand);
+    const leftToBorrow = new Dec(debtCeiling).minus(totalDebt).toString();
+    return Object.assign(Object.assign({}, data), { debtCeiling,
+        totalDebt,
+        ammPrice, oraclePrice: assetAmountInEth(data.oraclePrice, debtAsset), basePrice: assetAmountInEth(data.basePrice, debtAsset), minted: assetAmountInEth(data.minted, debtAsset), redeemed: assetAmountInEth(data.redeemed, debtAsset), borrowRate,
+        futureBorrowRate, bands: bandsData, leftToBorrow });
+});
+const getStatusForUser = (bandRange, activeBand, crvUSDSupplied, collSupplied) => {
+    // if bands are equal, that can only be [0,0] which means user doesn't have loan (min number of bands is 4)
+    if (new Dec(bandRange[0]).eq(bandRange[1]))
+        return CrvUSDStatus.Nonexistant;
+    // if user doesn't have crvUSD as collateral, then his position is not in soft liquidation
+    if (new Dec(crvUSDSupplied).lte(0)) {
+        if (new Dec(bandRange[0]).minus(activeBand).lte(3))
+            return CrvUSDStatus.Risk; // if user band is less than 3 bands away from active band, his position is at risk
+        return CrvUSDStatus.Safe;
+    }
+    if (new Dec(bandRange[0]).lte(activeBand) && new Dec(bandRange[1]).gte(activeBand))
+        return CrvUSDStatus.SoftLiquidating; // user has crvUSD as coll so he is in soft liquidation
+    if (new Dec(collSupplied).lte(0) || new Dec(bandRange[1]).lte(activeBand))
+        return CrvUSDStatus.SoftLiquidated; // or is fully soft liquidated
+    return CrvUSDStatus.Nonexistant;
+};
+export const getCrvUsdAccountBalances = (web3, network, block, addressMapping, address, crvUsdVersion) => __awaiter(void 0, void 0, void 0, function* () {
+    let balances = {
+        collateral: {},
+        debt: {},
+    };
+    if (!address) {
+        return balances;
+    }
+    const contract = CrvUSDViewContract(web3, network, block);
+    const selectedMarket = CrvUsdMarkets(network)[crvUsdVersion];
+    const data = yield contract.methods.userData(selectedMarket.controllerAddress, address).call({}, block);
+    balances = {
+        collateral: {
+            [addressMapping ? getAssetInfo(wethToEth(selectedMarket.collAsset), network).address.toLowerCase() : wethToEth(selectedMarket.collAsset)]: data.marketCollateralAmount,
+        },
+        debt: {
+            [addressMapping ? getAssetInfo(wethToEth(selectedMarket.baseAsset), network).address.toLowerCase() : wethToEth(selectedMarket.baseAsset)]: data.debtAmount,
+        },
+    };
+    return balances;
+});
+export const getCurveUsdUserData = (web3, network, address, selectedMarket, activeBand) => __awaiter(void 0, void 0, void 0, function* () {
+    const contract = CrvUSDViewContract(web3, network);
+    const data = yield contract.methods.userData(selectedMarket.controllerAddress, address).call();
+    const collAsset = selectedMarket.collAsset;
+    const debtAsset = selectedMarket.baseAsset;
+    const health = assetAmountInEth(data.health);
+    const healthPercent = new Dec(health).mul(100).toString();
+    const collPrice = assetAmountInEth(data.collateralPrice, debtAsset);
+    const collSupplied = assetAmountInEth(data.marketCollateralAmount, collAsset);
+    const collSuppliedUsd = new Dec(collSupplied).mul(collPrice).toString();
+    const crvUSDSupplied = assetAmountInEth(data.curveUsdCollateralAmount, debtAsset);
+    const debtBorrowed = assetAmountInEth(data.debtAmount, debtAsset);
+    const usedAssets = data.loanExists ? {
+        [collAsset]: {
+            isSupplied: true,
+            supplied: collSupplied,
+            suppliedUsd: collSuppliedUsd,
+            borrowed: '0',
+            borrowedUsd: '0',
+            isBorrowed: false,
+            symbol: collAsset,
+            collateral: true,
+            price: collPrice, // price_amm
+        },
+        [debtAsset]: {
+            isSupplied: new Dec(crvUSDSupplied).gt('0'),
+            collateral: new Dec(crvUSDSupplied).gt('0'),
+            supplied: crvUSDSupplied,
+            suppliedUsd: crvUSDSupplied,
+            borrowed: debtBorrowed,
+            borrowedUsd: debtBorrowed,
+            isBorrowed: new Dec(debtBorrowed).gt('0'),
+            symbol: 'crvUSD',
+            price: '1',
+            interestRate: '0',
+        },
+    } : {};
+    const priceHigh = assetAmountInEth(data.priceHigh);
+    const priceLow = assetAmountInEth(data.priceLow);
+    const _userBands = data.loanExists ? (yield getAndFormatBands(web3, network, selectedMarket, data.bandRange[0], data.bandRange[1])) : [];
+    const status = data.loanExists ? getStatusForUser(data.bandRange, activeBand, crvUSDSupplied, collSupplied) : CrvUSDStatus.Nonexistant;
+    const userBands = _userBands.map((band, index) => (Object.assign(Object.assign({}, band), { userDebtAmount: assetAmountInEth(data.usersBands[0][index], debtAsset), userCollAmount: assetAmountInEth(data.usersBands[1][index], collAsset) }))).sort((a, b) => parseInt(b.id, 10) - parseInt(a.id, 10));
+    return Object.assign(Object.assign(Object.assign(Object.assign({}, data), { debtAmount: assetAmountInEth(data.debtAmount, debtAsset), health,
+        healthPercent,
+        priceHigh,
+        priceLow, liquidationDiscount: assetAmountInEth(data.liquidationDiscount), numOfBands: data.N, usedAssets,
+        status }), getCrvUsdAggregatedData({
+        loanExists: data.loanExists, usedAssets, network: NetworkNumber.Eth, selectedMarket,
+    })), { userBands });
+});
+export const getCurveUsdFullPositionData = (web3, network, address, selectedMarket) => __awaiter(void 0, void 0, void 0, function* () {
+    const marketData = yield getCurveUsdGlobalData(web3, network, selectedMarket);
+    const positionData = yield getCurveUsdUserData(web3, network, address, selectedMarket, marketData.activeBand);
+    return positionData;
+});

package/esm/exchange/index.d.ts

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

package/esm/exchange/index.js

@@ -0,0 +1,19 @@
+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 { assetAmountInWei, getAssetInfoByAddress } from '@defisaver/tokens';
+import { wethToEthByAddress } from '../services/utils';
+export const getExchangeAccountBalances = (web3, network, block, addressMapping, subData) => __awaiter(void 0, void 0, void 0, function* () {
+    const fromToken = getAssetInfoByAddress(wethToEthByAddress(subData.fromToken, network), network);
+    return {
+        selling: {
+            [addressMapping ? fromToken.address.toLowerCase() : fromToken.symbol]: assetAmountInWei(subData.amount, fromToken.symbol),
+        },
+    };
+});

package/esm/helpers/aaveHelpers/index.d.ts

@@ -0,0 +1,37 @@
+import { AaveHelperCommon, AaveMarketInfo, AaveV3AggregatedPositionData, AaveV3AssetsData, AaveV3UsedAssets } from '../../types';
+export declare const isAaveV3: ({ selectedMarket }: {
+    selectedMarket: Partial<AaveMarketInfo>;
+}) => boolean;
+export declare const isMorphoAaveV2: ({ selectedMarket }: {
+    selectedMarket: Partial<AaveMarketInfo>;
+}) => boolean;
+export declare const isMorphoAaveV3: ({ selectedMarket }: {
+    selectedMarket: Partial<AaveMarketInfo>;
+}) => boolean;
+export declare const isMorphoAave: ({ selectedMarket }: {
+    selectedMarket: Partial<AaveMarketInfo>;
+}) => boolean;
+export declare const aaveV3IsInIsolationMode: ({ usedAssets, assetsData }: {
+    usedAssets: AaveV3UsedAssets;
+    assetsData: AaveV3AssetsData;
+}) => boolean;
+export declare const aaveV3IsInSiloedMode: ({ usedAssets, assetsData }: {
+    usedAssets: AaveV3UsedAssets;
+    assetsData: AaveV3AssetsData;
+}) => boolean;
+export declare const aaveAnyGetCollSuppliedAssets: ({ usedAssets }: {
+    usedAssets: AaveV3UsedAssets;
+}) => import("../../types").AaveV3UsedAsset[];
+export declare const aaveAnyGetSuppliableAssets: ({ usedAssets, eModeCategory, eModeCategories, assetsData, selectedMarket, network, ...rest }: AaveHelperCommon) => {
+    symbol: string;
+    canBeCollateral: boolean;
+}[];
+export declare const aaveAnyGetSuppliableAsCollAssets: ({ usedAssets, eModeCategory, eModeCategories, assetsData, selectedMarket, network, ...rest }: AaveHelperCommon) => {
+    symbol: string;
+    canBeCollateral: boolean;
+}[];
+export declare const aaveAnyGetEmodeMutableProps: ({ usedAssets, eModeCategory, eModeCategories, assetsData, selectedMarket, network, ...rest }: AaveHelperCommon, _asset: string) => {
+    liquidationRatio: any;
+    collateralFactor: any;
+};
+export declare const aaveAnyGetAggregatedPositionData: ({ usedAssets, eModeCategory, eModeCategories, assetsData, selectedMarket, network, ...rest }: AaveHelperCommon) => AaveV3AggregatedPositionData;

package/esm/helpers/aaveHelpers/index.js

@@ -0,0 +1,101 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import Dec from 'decimal.js';
+import { AaveVersions, } from '../../types';
+import { wethToEth } from '../../services/utils';
+import { calcLeverageLiqPrice, getAssetsTotal, isLeveragedPos } from '../../moneymarket';
+import { calculateNetApy } from '../../staking';
+export const isAaveV3 = ({ selectedMarket }) => selectedMarket.value === AaveVersions.AaveV3;
+export const isMorphoAaveV2 = ({ selectedMarket }) => selectedMarket.value === AaveVersions.MorphoAaveV2;
+export const isMorphoAaveV3 = ({ selectedMarket }) => selectedMarket.value === AaveVersions.MorphoAaveV3Eth;
+export const isMorphoAave = ({ selectedMarket }) => isMorphoAaveV2({ selectedMarket }) || isMorphoAaveV3({ selectedMarket });
+export const aaveV3IsInIsolationMode = ({ usedAssets, assetsData }) => Object.values(usedAssets).some(({ symbol, collateral }) => collateral && assetsData[symbol].isIsolated);
+export const aaveV3IsInSiloedMode = ({ usedAssets, assetsData }) => Object.values(usedAssets).some(({ symbol, debt }) => debt && assetsData[symbol].isSiloed);
+export const aaveAnyGetCollSuppliedAssets = ({ usedAssets }) => Object.values(usedAssets)
+    .filter(({ isSupplied, collateral }) => isSupplied && collateral);
+export const aaveAnyGetSuppliableAssets = (_a) => {
+    var { usedAssets, eModeCategory, eModeCategories, assetsData, selectedMarket, network } = _a, rest = __rest(_a, ["usedAssets", "eModeCategory", "eModeCategories", "assetsData", "selectedMarket", "network"]);
+    const data = Object.assign({ usedAssets, eModeCategory, eModeCategories, assetsData, selectedMarket, network }, rest);
+    const collAccountAssets = aaveAnyGetCollSuppliedAssets(data);
+    const marketAssets = Object.values(assetsData);
+    if (isMorphoAave({ selectedMarket })) {
+        return marketAssets.filter(({ canBeSupplied }) => canBeSupplied).map(a => (Object.assign(Object.assign({}, a), { canBeCollateral: new Dec(assetsData[a.symbol].collateralFactor).gt(0) })));
+    }
+    if (collAccountAssets.length === 0 || !isAaveV3(data))
+        return marketAssets.filter(({ canBeSupplied }) => canBeSupplied).map(({ symbol }) => ({ symbol, canBeCollateral: true }));
+    if (aaveV3IsInIsolationMode(data)) {
+        const collAsset = collAccountAssets[0].symbol;
+        return marketAssets.filter(d => d.canBeSupplied).map(({ symbol }) => ({ symbol, canBeCollateral: symbol === collAsset }));
+    }
+    return marketAssets.filter(d => d.canBeSupplied).map(({ symbol, isIsolated }) => ({ symbol, canBeCollateral: !isIsolated }));
+};
+export const aaveAnyGetSuppliableAsCollAssets = (_a) => {
+    var { usedAssets, eModeCategory, eModeCategories, assetsData, selectedMarket, network } = _a, rest = __rest(_a, ["usedAssets", "eModeCategory", "eModeCategories", "assetsData", "selectedMarket", "network"]);
+    return aaveAnyGetSuppliableAssets(Object.assign({ usedAssets, eModeCategory, eModeCategories, assetsData, selectedMarket, network }, rest)).filter(({ canBeCollateral }) => canBeCollateral);
+};
+export const aaveAnyGetEmodeMutableProps = (_a, _asset) => {
+    var _b;
+    var { usedAssets, eModeCategory, eModeCategories, assetsData, selectedMarket, network } = _a, rest = __rest(_a, ["usedAssets", "eModeCategory", "eModeCategories", "assetsData", "selectedMarket", "network"]);
+    const data = Object.assign({ usedAssets, eModeCategory, eModeCategories, assetsData, selectedMarket, network }, rest);
+    const asset = wethToEth(_asset);
+    const canSupplyAsColl = aaveAnyGetSuppliableAsCollAssets(data).some(({ symbol }) => symbol === asset);
+    // TODO remove dirty fix for Morpho V2
+    if (isMorphoAaveV2({ selectedMarket }) && !canSupplyAsColl) {
+        const { liquidationRatio, collateralFactor } = assetsData[asset];
+        return ({ liquidationRatio, collateralFactor });
+    }
+    if (!canSupplyAsColl) {
+        return ({ liquidationRatio: '0', collateralFactor: '0' });
+    }
+    const assetData = assetsData[asset];
+    if (eModeCategory === 0
+        || assetData.eModeCategory !== eModeCategory
+        || new Dec(((_b = assetData === null || assetData === void 0 ? void 0 : assetData.eModeCategoryData) === null || _b === void 0 ? void 0 : _b.collateralFactor) || 0).eq(0)) {
+        const { liquidationRatio, collateralFactor } = assetData;
+        return ({ liquidationRatio, collateralFactor });
+    }
+    const { liquidationRatio, collateralFactor } = assetData.eModeCategoryData;
+    return ({ liquidationRatio, collateralFactor });
+};
+export const aaveAnyGetAggregatedPositionData = (_a) => {
+    var { usedAssets, eModeCategory, eModeCategories, assetsData, selectedMarket, network } = _a, rest = __rest(_a, ["usedAssets", "eModeCategory", "eModeCategories", "assetsData", "selectedMarket", "network"]);
+    const data = Object.assign({ usedAssets, eModeCategory, eModeCategories, assetsData, selectedMarket, network }, rest);
+    const payload = {};
+    payload.suppliedUsd = getAssetsTotal(usedAssets, ({ isSupplied }) => isSupplied, ({ suppliedUsd }) => suppliedUsd);
+    payload.suppliedCollateralUsd = getAssetsTotal(usedAssets, ({ isSupplied, collateral }) => isSupplied && collateral, ({ suppliedUsd }) => suppliedUsd);
+    payload.borrowLimitUsd = getAssetsTotal(usedAssets, ({ isSupplied, collateral }) => isSupplied && collateral, ({ symbol, suppliedUsd }) => new Dec(suppliedUsd).mul(aaveAnyGetEmodeMutableProps(data, symbol).collateralFactor));
+    payload.liquidationLimitUsd = getAssetsTotal(usedAssets, ({ isSupplied, collateral }) => isSupplied && collateral, ({ symbol, suppliedUsd }) => new Dec(suppliedUsd).mul(aaveAnyGetEmodeMutableProps(data, symbol).liquidationRatio));
+    payload.borrowedUsd = getAssetsTotal(usedAssets, ({ isBorrowed }) => isBorrowed, ({ borrowedUsd }) => borrowedUsd);
+    const leftToBorrowUsd = new Dec(payload.borrowLimitUsd).sub(payload.borrowedUsd);
+    payload.leftToBorrowUsd = leftToBorrowUsd.lte('0') ? '0' : leftToBorrowUsd.toString();
+    payload.ratio = +payload.suppliedUsd ? new Dec(payload.borrowLimitUsd).div(payload.borrowedUsd).mul(100).toString() : '0';
+    payload.collRatio = +payload.suppliedUsd ? new Dec(payload.suppliedCollateralUsd).div(payload.borrowedUsd).mul(100).toString() : '0';
+    const { netApy, incentiveUsd, totalInterestUsd } = calculateNetApy(usedAssets, assetsData, isMorphoAave({ selectedMarket }));
+    payload.netApy = netApy;
+    payload.incentiveUsd = incentiveUsd;
+    payload.totalInterestUsd = totalInterestUsd;
+    payload.liqRatio = new Dec(payload.borrowLimitUsd).div(payload.liquidationLimitUsd).toString();
+    payload.liqPercent = new Dec(payload.borrowLimitUsd).div(payload.liquidationLimitUsd).mul(100).toString();
+    const { leveragedType, leveragedAsset } = isLeveragedPos(usedAssets);
+    payload.leveragedType = leveragedType;
+    if (leveragedType !== '') {
+        payload.leveragedAsset = leveragedAsset;
+        let assetPrice = data.assetsData[leveragedAsset].price;
+        if (leveragedType === 'lsd-leverage') {
+            // Treat ETH like a stablecoin in a long stETH position
+            payload.leveragedLsdAssetRatio = new Dec(assetsData[leveragedAsset].price).div(assetsData.ETH.price).toDP(18).toString();
+            assetPrice = new Dec(assetPrice).div(assetsData.ETH.price).toString();
+        }
+        payload.liquidationPrice = calcLeverageLiqPrice(leveragedType, assetPrice, payload.borrowedUsd, payload.liquidationLimitUsd);
+    }
+    return payload;
+};

package/esm/helpers/compoundHelpers/index.d.ts

@@ -0,0 +1,20 @@
+import { BaseAdditionalAssetData, CompoundAggregatedPositionData, CompoundMarketData, CompoundV2AssetsData, CompoundV2UsedAssets, CompoundV3AssetData, CompoundV3AssetsData, CompoundV3UsedAssets } from '../../types';
+import { NetworkNumber } from '../../types/common';
+export declare const formatMarketData: (data: any, network: NetworkNumber) => CompoundV3AssetData;
+export declare const formatBaseData: (data: any, network: NetworkNumber) => CompoundV3AssetData & BaseAdditionalAssetData;
+export declare const getIncentiveApys: (baseData: CompoundV3AssetData & BaseAdditionalAssetData, compPrice: string) => {
+    incentiveSupplyApy: string;
+    incentiveBorrowApy: string;
+    incentiveSupplyToken: string;
+    incentiveBorrowToken: string;
+};
+export declare const getCompoundV2AggregatedData: ({ usedAssets, assetsData, ...rest }: {
+    usedAssets: CompoundV2UsedAssets;
+    assetsData: CompoundV2AssetsData;
+}) => CompoundAggregatedPositionData;
+export declare const getCompoundV3AggregatedData: ({ usedAssets, assetsData, network, selectedMarket, ...rest }: {
+    usedAssets: CompoundV3UsedAssets;
+    assetsData: CompoundV3AssetsData;
+    network: NetworkNumber;
+    selectedMarket: CompoundMarketData;
+}) => CompoundAggregatedPositionData;

package/esm/helpers/compoundHelpers/index.js

@@ -0,0 +1,130 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import Dec from 'decimal.js';
+import { getAssetInfoByAddress } from '@defisaver/tokens';
+import { CompoundVersions, } from '../../types';
+import { getEthAmountForDecimals, handleWbtcLegacy, wethToEth } from '../../services/utils';
+import { SECONDS_PER_YEAR } from '../../constants';
+import { aprToApy, calcLeverageLiqPrice, calculateBorrowingAssetLimit, getAssetsTotal, isLeveragedPos, } from '../../moneymarket';
+import { calculateNetApy } from '../../staking';
+export const formatMarketData = (data, network) => {
+    const assetInfo = getAssetInfoByAddress(data.tokenAddr, network);
+    const isWETH = assetInfo.symbol === 'WETH';
+    return (Object.assign(Object.assign({}, data), { price: getEthAmountForDecimals(data.price, 8), collateralFactor: getEthAmountForDecimals(data.borrowCollateralFactor, 18), liquidationRatio: getEthAmountForDecimals(data.liquidateCollateralFactor, 18), supplyCap: getEthAmountForDecimals(data.supplyCap, assetInfo.decimals), totalSupply: getEthAmountForDecimals(data.totalSupply, assetInfo.decimals), symbol: isWETH ? 'ETH' : assetInfo.symbol, supplyRate: '0', borrowRate: '0', canBeBorrowed: false, canBeSupplied: true }));
+};
+// TODO: maybe not hardcode decimals
+export const formatBaseData = (data, network) => {
+    const assetInfo = getAssetInfoByAddress(data.tokenAddr, network);
+    const totalSupply = getEthAmountForDecimals(new Dec(data.totalSupply).mul(data.supplyIndex).toString(), 15 + assetInfo.decimals);
+    const totalBorrow = getEthAmountForDecimals(new Dec(data.totalBorrow).mul(data.borrowIndex).toString(), 15 + assetInfo.decimals);
+    return (Object.assign(Object.assign({}, data), { supplyRate: aprToApy(new Dec(data.supplyRate).div(1e18).mul(SECONDS_PER_YEAR).mul(100)
+            .toString()), borrowRate: aprToApy(new Dec(data.borrowRate).div(1e18).mul(SECONDS_PER_YEAR).mul(100)
+            .toString()), utilization: getEthAmountForDecimals(data.utilization, 16), // utilization is totalSupply/totalBorrow in 1e18, but we need % so when we mul with 100 it's 16 decimals
+        totalSupply,
+        totalBorrow, marketLiquidity: new Dec(totalSupply).minus(totalBorrow).toString(), symbol: wethToEth(assetInfo.symbol), price: getEthAmountForDecimals(data.price, 8), collateralFactor: '0', liquidationRatio: '0', canBeBorrowed: true, canBeSupplied: true, supplyCap: '0', rewardSupplySpeed: getEthAmountForDecimals(data.baseTrackingSupplyRewardsSpeed, 15), rewardBorrowSpeed: getEthAmountForDecimals(data.baseTrackingBorrowRewardsSpeed, 15), minDebt: getEthAmountForDecimals(data.baseBorrowMin, assetInfo.decimals), isBase: true }));
+};
+export const getIncentiveApys = (baseData, compPrice) => {
+    const incentiveSupplyApy = aprToApy((100 * SECONDS_PER_YEAR * +baseData.rewardSupplySpeed * +compPrice) / +baseData.price / +baseData.totalSupply).toString();
+    const incentiveBorrowApy = aprToApy((100 * SECONDS_PER_YEAR * +baseData.rewardBorrowSpeed * +compPrice) / +baseData.price / +baseData.totalBorrow).toString();
+    return {
+        incentiveSupplyApy,
+        incentiveBorrowApy,
+        incentiveSupplyToken: 'COMP',
+        incentiveBorrowToken: 'COMP',
+    };
+};
+export const getCompoundV2AggregatedData = (_a) => {
+    var { usedAssets, assetsData } = _a, rest = __rest(_a, ["usedAssets", "assetsData"]);
+    const payload = {};
+    payload.suppliedUsd = getAssetsTotal(usedAssets, ({ isSupplied }) => isSupplied, ({ suppliedUsd }) => suppliedUsd);
+    payload.suppliedCollateralUsd = getAssetsTotal(usedAssets, ({ isSupplied, collateral }) => isSupplied && collateral, ({ suppliedUsd }) => suppliedUsd);
+    payload.borrowedUsd = getAssetsTotal(usedAssets, ({ isBorrowed }) => isBorrowed, ({ borrowedUsd }) => borrowedUsd);
+    payload.borrowLimitUsd = getAssetsTotal(usedAssets, ({ isSupplied, collateral }) => isSupplied && collateral, ({ symbol, suppliedUsd }) => new Dec(suppliedUsd).mul(assetsData[symbol].collateralFactor));
+    const leftToBorrowUsd = new Dec(payload.borrowLimitUsd).sub(payload.borrowedUsd).toString();
+    payload.leftToBorrowUsd = leftToBorrowUsd;
+    payload.borrowLimitUsd = new Dec(leftToBorrowUsd).add(payload.borrowedUsd).toString();
+    payload.liquidationLimitUsd = payload.borrowLimitUsd;
+    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(usedAssets).forEach((item) => {
+        if (item.isBorrowed) {
+            // 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;
+    const { leveragedType, leveragedAsset } = isLeveragedPos(usedAssets);
+    payload.leveragedType = leveragedType;
+    if (leveragedType !== '') {
+        payload.leveragedAsset = leveragedAsset;
+        const assetPrice = assetsData[handleWbtcLegacy(leveragedAsset)].price;
+        payload.liquidationPrice = calcLeverageLiqPrice(leveragedType, assetPrice, payload.borrowedUsd, payload.liquidationLimitUsd);
+    }
+    return payload;
+};
+export const getCompoundV3AggregatedData = (_a) => {
+    var _b;
+    var { usedAssets, assetsData, network, selectedMarket } = _a, rest = __rest(_a, ["usedAssets", "assetsData", "network", "selectedMarket"]);
+    const payload = {};
+    payload.suppliedUsd = getAssetsTotal(usedAssets, ({ isSupplied }) => isSupplied, ({ suppliedUsd }) => suppliedUsd);
+    payload.suppliedCollateralUsd = getAssetsTotal(usedAssets, ({ isSupplied, collateral }) => isSupplied && collateral, ({ suppliedUsd }) => suppliedUsd);
+    payload.borrowedUsd = getAssetsTotal(usedAssets, ({ isBorrowed }) => isBorrowed, ({ borrowedUsd }) => borrowedUsd);
+    payload.borrowLimitUsd = getAssetsTotal(usedAssets, ({ isSupplied, collateral }) => isSupplied && collateral, ({ symbol, suppliedUsd }) => new Dec(suppliedUsd).mul(assetsData[symbol].collateralFactor));
+    payload.liquidationLimitUsd = getAssetsTotal(usedAssets, ({ isSupplied, collateral }) => isSupplied && collateral, ({ symbol, suppliedUsd }) => new Dec(suppliedUsd).mul(assetsData[symbol].liquidationRatio));
+    payload.debtTooLow = new Dec(((_b = usedAssets[selectedMarket.baseAsset]) === null || _b === void 0 ? void 0 : _b.borrowed) || 0).gt(0) && new Dec(usedAssets[selectedMarket.baseAsset].borrowed).lt(assetsData[selectedMarket.baseAsset].minDebt);
+    const leftToBorrowUsd = new Dec(payload.borrowLimitUsd).sub(payload.borrowedUsd);
+    payload.leftToBorrowUsd = leftToBorrowUsd.lte('0') ? '0' : leftToBorrowUsd.toString();
+    payload.ratio = +payload.suppliedUsd ? new Dec(payload.borrowLimitUsd).div(payload.borrowedUsd).mul(100).toString() : '0';
+    payload.collRatio = +payload.suppliedUsd ? new Dec(payload.suppliedCollateralUsd).div(payload.borrowedUsd).mul(100).toString() : '0';
+    const { netApy, incentiveUsd, totalInterestUsd } = calculateNetApy(usedAssets, assetsData);
+    payload.netApy = netApy;
+    payload.incentiveUsd = incentiveUsd;
+    payload.totalInterestUsd = totalInterestUsd;
+    payload.minRatio = '100';
+    payload.liqRatio = new Dec(payload.borrowLimitUsd).div(payload.liquidationLimitUsd).toString();
+    payload.liqPercent = new Dec(payload.borrowLimitUsd).div(payload.liquidationLimitUsd).mul(100).toString();
+    payload.minDebt = assetsData[selectedMarket.baseAsset].minDebt;
+    const { leveragedType, leveragedAsset } = isLeveragedPos(usedAssets, selectedMarket.value === CompoundVersions.CompoundV3ETH ? 0.001 : 5);
+    payload.leveragedType = leveragedType;
+    if (leveragedType !== '') {
+        payload.leveragedAsset = leveragedAsset;
+        const assetPrice = assetsData[leveragedAsset].price;
+        if (leveragedType === 'lsd-leverage') {
+            payload.leveragedLsdAssetRatio = new Dec(assetsData[leveragedAsset].price).div(assetsData.ETH.price).toString();
+        }
+        payload.liquidationPrice = calcLeverageLiqPrice(leveragedType, assetPrice, payload.borrowedUsd, payload.liquidationLimitUsd);
+    }
+    // TO DO: handle strategies
+    /* const subscribedStrategies = rest.compoundStrategies
+      ? compoundV3GetSubscribedStrategies({ selectedMarket, compoundStrategies: rest.compoundStrategies })
+      : []; */
+    // TODO possibly move to global helper, since every protocol has the same graphData?
+    // payload.ratioTooLow = false;
+    // payload.ratioTooHigh = false;
+    // TO DO: handle strategies
+    /* if (subscribedStrategies.length) {
+      subscribedStrategies.forEach(({ graphData }) => {
+        payload.ratioTooLow = parseFloat(payload.ratio) < parseFloat(graphData.minRatio);
+        payload.ratioTooHigh = graphData.boostEnabled && parseFloat(payload.ratio) > parseFloat(graphData.maxRatio);
+      });
+    } */
+    return payload;
+};

package/esm/helpers/curveUsdHelpers/index.d.ts

@@ -0,0 +1,8 @@
+import { CrvUSDAggregatedPositionData, CrvUSDMarketData, CrvUSDUsedAssets } from '../../types';
+import { NetworkNumber } from '../../types/common';
+export declare const getCrvUsdAggregatedData: ({ loanExists, usedAssets, network, selectedMarket, ...rest }: {
+    loanExists: boolean;
+    usedAssets: CrvUSDUsedAssets;
+    network: NetworkNumber;
+    selectedMarket: CrvUSDMarketData;
+}) => CrvUSDAggregatedPositionData;