@defisaver/positions-sdk 0.0.1

package/src/constants/index.ts

@@ -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/src/contracts.ts

@@ -0,0 +1,95 @@
+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, EthAddress, NetworkNumber } from './types/common';
+
+export type ConfigKey = keyof typeof configRaw;
+
+declare type ContractConfig = {
+  abi: any[],
+  networks: Partial<Record<NetworkNumber, Network>>,
+};
+declare type Network = {
+  createdBlock?: number,
+  address: string,
+  oldVersions?: Record<string, EthAddress>,
+};
+const contractConfig:Record<ConfigKey, ContractConfig> = configRaw;
+export const getConfigContractAddress = (name: ConfigKey, network: NetworkNumber, block?: Blockish): string => {
+  const networkData = contractConfig[name].networks[network];
+  const latestAddress = networkData?.address || '';
+  if (block && block !== 'latest') {
+    if (block >= (networkData?.createdBlock || 0)) {
+      return latestAddress;
+    }
+
+    const oldVersions = networkData?.oldVersions || {};
+    for (const [createdBlock, address] of Object.entries(oldVersions).reverse()) {
+      if (block >= Number(createdBlock)) {
+        return address;
+      }
+    }
+  }
+  return latestAddress;
+};
+export const getConfigContractAbi = (name: ConfigKey): any[] => contractConfig[name].abi;
+
+const createContractFromConfigFunc = <T extends BaseContract>(name: ConfigKey, _address?: string) => (web3: Web3, network: NetworkNumber, block?: Blockish) => {
+  const address = _address || getConfigContractAddress(name, network, block);
+  return new web3.eth.Contract(contractConfig[name].abi, address) as any as T;
+};
+
+export const getErc20Contract = (address: string, web3: Web3) => (
+  new web3.eth.Contract(getConfigContractAbi('Erc20'), address)
+);
+
+export const createContractWrapper = (web3: Web3, network: NetworkNumber, name: ConfigKey, _address?: string, block?: Blockish) => (
+  createContractFromConfigFunc(name, _address)(web3, network, block)
+);
+
+export const UniMulticallContract = createContractFromConfigFunc<ContractTypes.UniMulticall>('UniMulticall');
+
+export const AaveV3ViewContract = createContractFromConfigFunc<ContractTypes.AaveV3View>('AaveV3View');
+export const AaveIncentiveDataProviderV3Contract = createContractFromConfigFunc<ContractTypes.AaveUiIncentiveDataProviderV3>('AaveUiIncentiveDataProviderV3');
+
+export const GhoTokenContract = createContractFromConfigFunc<ContractTypes.GHO>('GHO');
+
+export const LidoContract = createContractFromConfigFunc<ContractTypes.Lido>('Lido');
+export const CbEthContract = createContractFromConfigFunc<ContractTypes.CbEth>('CbEth');
+export const REthContract = createContractFromConfigFunc<ContractTypes.REth>('REth');
+
+export const BalanceScannerContract = createContractFromConfigFunc<ContractTypes.BalanceScanner>('BalanceScanner');
+
+export const CompV3ViewContract = createContractFromConfigFunc<ContractTypes.CompV3View>('CompV3View');
+
+export const wstETHContract = createContractFromConfigFunc<ContractTypes.WstETH>('wstETH');
+
+export const AaveLoanInfoV2Contract = createContractFromConfigFunc<ContractTypes.AaveLoanInfoV2>('AaveLoanInfoV2');
+
+export const CompoundLoanInfoContract = createContractFromConfigFunc<ContractTypes.CompoundLoanInfo>('CompoundLoanInfo');
+
+export const ComptrollerContract = createContractFromConfigFunc<ContractTypes.Comptroller>('Comptroller');
+
+export const PotContract = createContractFromConfigFunc<ContractTypes.Pot>('Pot');
+
+export const MorphoAaveV2ViewContract = createContractFromConfigFunc<ContractTypes.MorphoAaveV2View>('MorphoAaveV2View');
+
+export const SparkIncentiveDataProviderContract = createContractFromConfigFunc<ContractTypes.SparkIncentiveDataProvider>('SparkIncentiveDataProvider');
+export const SparkViewContract = createContractFromConfigFunc<ContractTypes.SparkView>('SparkView');
+
+export const CrvUSDViewContract = createContractFromConfigFunc<ContractTypes.CrvUSDView>('crvUSDView');
+export const CrvUSDFactoryContract = createContractFromConfigFunc<ContractTypes.CrvUSDFactory>('crvUSDFactory');
+
+export const LiquityViewContract = createContractFromConfigFunc<ContractTypes.LiquityView>('LiquityView');
+export const LiquityCollSurplusPoolContract = createContractFromConfigFunc<ContractTypes.CollSurplusPool>('CollSurplusPool');
+export const LiquityTroveManagerContract = createContractFromConfigFunc<ContractTypes.TroveManager>('TroveManager');
+export const LiquityPriceFeedContract = createContractFromConfigFunc<ContractTypes.PriceFeed>('PriceFeed');
+export const LiquityActivePoolContract = createContractFromConfigFunc<ContractTypes.LiquityActivePool>('LiquityActivePool');
+
+export const McdViewContract = createContractFromConfigFunc<ContractTypes.McdView>('McdView');
+export const McdSpotterContract = createContractFromConfigFunc<ContractTypes.McdSpotter>('McdSpotter');
+export const McdDogContract = createContractFromConfigFunc<ContractTypes.McdDog>('McdDog');
+export const McdJugContract = createContractFromConfigFunc<ContractTypes.McdJug>('McdJug');
+export const McdVatContract = createContractFromConfigFunc<ContractTypes.McdVat>('McdVat');
+export const ChickenBondsViewContract = createContractFromConfigFunc<ContractTypes.ChickenBondsView>('ChickenBondsView');

package/src/curveUsd/index.ts

@@ -0,0 +1,229 @@
+import Dec from 'decimal.js';
+import { assetAmountInEth, getAssetInfo } from '@defisaver/tokens';
+import Web3 from 'web3';
+import {
+  BandData, CrvUSDGlobalMarketData, CrvUSDMarketData, CrvUSDStatus, CrvUSDUsedAssets, CrvUSDUserData, CrvUSDVersions,
+} from '../types';
+import { multicall } from '../multicall';
+import {
+  Blockish, EthAddress, NetworkNumber, PositionBalances,
+} from '../types/common';
+import { CrvUSDFactoryContract, CrvUSDViewContract } from '../contracts';
+import { getCrvUsdAggregatedData } from '../helpers/curveUsdHelpers';
+import { CrvUsdMarkets } from '../markets';
+import { wethToEth } from '../services/utils';
+
+const getAndFormatBands = async (web3: Web3, network: NetworkNumber, selectedMarket: CrvUSDMarketData, _minBand: string, _maxBand: string) => {
+  const contract = CrvUSDViewContract(web3, network);
+  const minBand = parseInt(_minBand, 10);
+  const maxBand = parseInt(_maxBand, 10);
+  const pivots: number[] = [];
+
+  // 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 = (await Promise.all(pivots.map(async (pivot, index) => {
+    let start = 0;
+    if (index === 0) {
+      start = minBand;
+    } else {
+      start = pivots[index - 1] + 1;
+    }
+    // @ts-ignore
+    const pivotedBandsData = await contract.methods.getBandsData(selectedMarket.controllerAddress, start, pivot).call();
+    return pivotedBandsData;
+  }))).flat();
+
+  return bandsData.map((band: BandData) => ({
+    id: band.id,
+    collAmount: assetAmountInEth(band.collAmount),
+    debtAmount: assetAmountInEth(band.debtAmount),
+    lowPrice: assetAmountInEth(band.lowPrice),
+    highPrice: assetAmountInEth(band.highPrice),
+  }));
+};
+
+export const getCurveUsdGlobalData = async (web3: Web3, network: NetworkNumber, selectedMarket: CrvUSDMarketData): Promise<CrvUSDGlobalMarketData> => {
+  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 = await 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 = await getAndFormatBands(web3, network, selectedMarket, data.minBand, data.maxBand);
+
+  const leftToBorrow = new Dec(debtCeiling).minus(totalDebt).toString();
+  return {
+    ...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: string[], activeBand: string, crvUSDSupplied: string, collSupplied: string) => {
+  // 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 = async (web3: Web3, network: NetworkNumber, block: Blockish, addressMapping: boolean, address: EthAddress, crvUsdVersion: CrvUSDVersions): Promise<PositionBalances> => {
+  let balances: PositionBalances = {
+    collateral: {},
+    debt: {},
+  };
+
+  if (!address) {
+    return balances;
+  }
+
+  const contract = CrvUSDViewContract(web3, network, block);
+  const selectedMarket = CrvUsdMarkets(network)[crvUsdVersion];
+
+  const data = await 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 = async (web3: Web3, network: NetworkNumber, address: string, selectedMarket: CrvUSDMarketData, activeBand: string): Promise<CrvUSDUserData> => {
+  const contract = CrvUSDViewContract(web3, network);
+
+  const data = await 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: CrvUSDUsedAssets = data.loanExists ? {
+    [collAsset]: {
+      isSupplied: true,
+      supplied: collSupplied,
+      suppliedUsd: collSuppliedUsd, // need oracle price, or amm price
+      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 ? (await 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) => ({
+    ...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 {
+    ...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 = async (web3: Web3, network: NetworkNumber, address: string, selectedMarket: CrvUSDMarketData): Promise<CrvUSDUserData> => {
+  const marketData = await getCurveUsdGlobalData(web3, network, selectedMarket);
+  const positionData = await getCurveUsdUserData(web3, network, address, selectedMarket, marketData.activeBand);
+  return positionData;
+};

package/src/exchange/index.ts

@@ -0,0 +1,17 @@
+import Web3 from 'web3';
+
+import { assetAmountInWei, getAssetInfoByAddress } from '@defisaver/tokens';
+import {
+  Blockish, NetworkNumber, PositionBalances,
+} from '../types/common';
+import { wethToEthByAddress } from '../services/utils';
+
+export const getExchangeAccountBalances = async (web3: Web3, network: NetworkNumber, block: Blockish, addressMapping: boolean, subData: any): Promise<PositionBalances> => {
+  const fromToken = getAssetInfoByAddress(wethToEthByAddress(subData.fromToken, network), network);
+
+  return {
+    selling: {
+      [addressMapping ? fromToken.address.toLowerCase() : fromToken.symbol]: assetAmountInWei(subData.amount, fromToken.symbol),
+    },
+  };
+};

package/src/helpers/aaveHelpers/index.ts

@@ -0,0 +1,138 @@
+import Dec from 'decimal.js';
+import {
+  AaveAssetData, AaveHelperCommon, AaveMarketInfo, AaveV3AggregatedPositionData, AaveV3AssetsData, AaveV3UsedAssets, AaveVersions,
+} from '../../types';
+import { wethToEth } from '../../services/utils';
+import { calcLeverageLiqPrice, getAssetsTotal, isLeveragedPos } from '../../moneymarket';
+import { calculateNetApy } from '../../staking';
+
+export const isAaveV3 = ({ selectedMarket }: { selectedMarket: Partial<AaveMarketInfo> }) => selectedMarket.value === AaveVersions.AaveV3;
+export const isMorphoAaveV2 = ({ selectedMarket }: { selectedMarket: Partial<AaveMarketInfo> }) => selectedMarket.value === AaveVersions.MorphoAaveV2;
+export const isMorphoAaveV3 = ({ selectedMarket }: { selectedMarket: Partial<AaveMarketInfo> }) => selectedMarket.value === AaveVersions.MorphoAaveV3Eth;
+export const isMorphoAave = ({ selectedMarket }: { selectedMarket: Partial<AaveMarketInfo> }) => isMorphoAaveV2({ selectedMarket }) || isMorphoAaveV3({ selectedMarket });
+
+export const aaveV3IsInIsolationMode = ({ usedAssets, assetsData }: { usedAssets: AaveV3UsedAssets, assetsData: AaveV3AssetsData }) => Object.values(usedAssets).some(({ symbol, collateral }) => collateral && assetsData[symbol].isIsolated);
+export const aaveV3IsInSiloedMode = ({ usedAssets, assetsData }: { usedAssets: AaveV3UsedAssets, assetsData: AaveV3AssetsData }) => Object.values(usedAssets).some(({ symbol, debt }) => debt && assetsData[symbol].isSiloed);
+
+export const aaveAnyGetCollSuppliedAssets = ({ usedAssets }: { usedAssets: AaveV3UsedAssets }) => Object.values(usedAssets)
+  .filter(({ isSupplied, collateral }: { isSupplied: boolean, collateral: boolean }) => isSupplied && collateral);
+
+export const aaveAnyGetSuppliableAssets = ({
+  usedAssets, eModeCategory, eModeCategories, assetsData, selectedMarket, network, ...rest
+}: AaveHelperCommon) => {
+  const data = {
+    usedAssets, eModeCategory, eModeCategories, assetsData, selectedMarket, network, ...rest,
+  };
+
+  const collAccountAssets = aaveAnyGetCollSuppliedAssets(data);
+  const marketAssets = Object.values(assetsData) as AaveAssetData[];
+
+  if (isMorphoAave({ selectedMarket })) {
+    return marketAssets.filter(({ canBeSupplied }) => canBeSupplied,
+    ).map(a => ({ ...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 = ({
+  usedAssets, eModeCategory, eModeCategories, assetsData, selectedMarket, network, ...rest
+}: AaveHelperCommon) => aaveAnyGetSuppliableAssets({
+  usedAssets, eModeCategory, eModeCategories, assetsData, selectedMarket, network, ...rest,
+}).filter(({ canBeCollateral }) => canBeCollateral);
+
+export const aaveAnyGetEmodeMutableProps = (
+  {
+    usedAssets,
+    eModeCategory,
+    eModeCategories,
+    assetsData,
+    selectedMarket,
+    network,
+    ...rest
+  }: AaveHelperCommon, _asset: string) => {
+  const data = {
+    usedAssets, eModeCategory, eModeCategories, assetsData, selectedMarket, network, ...rest,
+  };
+  const asset = wethToEth(_asset);
+  const canSupplyAsColl = aaveAnyGetSuppliableAsCollAssets(data).some(({ symbol }: { symbol: string }) => 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(assetData?.eModeCategoryData?.collateralFactor || 0).eq(0)
+  ) {
+    const { liquidationRatio, collateralFactor } = assetData;
+    return ({ liquidationRatio, collateralFactor });
+  }
+  const { liquidationRatio, collateralFactor } = assetData.eModeCategoryData;
+  return ({ liquidationRatio, collateralFactor });
+};
+
+export const aaveAnyGetAggregatedPositionData = ({
+  usedAssets,
+  eModeCategory,
+  eModeCategories,
+  assetsData,
+  selectedMarket,
+  network,
+  ...rest
+}: AaveHelperCommon): AaveV3AggregatedPositionData => {
+  const data = {
+    usedAssets, eModeCategory, eModeCategories, assetsData, selectedMarket, network, ...rest,
+  };
+  const payload = {} as AaveV3AggregatedPositionData;
+  payload.suppliedUsd = getAssetsTotal(usedAssets, ({ isSupplied }: { isSupplied: boolean }) => isSupplied, ({ suppliedUsd }: { suppliedUsd: string }) => suppliedUsd);
+  payload.suppliedCollateralUsd = getAssetsTotal(usedAssets, ({ isSupplied, collateral }: { isSupplied: boolean, collateral: string }) => isSupplied && collateral, ({ suppliedUsd }: { suppliedUsd: string }) => suppliedUsd);
+  payload.borrowLimitUsd = getAssetsTotal(
+    usedAssets,
+    ({ isSupplied, collateral }: { isSupplied: boolean, collateral: string }) => isSupplied && collateral,
+    ({ symbol, suppliedUsd }: { symbol: string, suppliedUsd: string }) => new Dec(suppliedUsd).mul(aaveAnyGetEmodeMutableProps(data, symbol).collateralFactor),
+  );
+  payload.liquidationLimitUsd = getAssetsTotal(
+    usedAssets,
+    ({ isSupplied, collateral }: { isSupplied: boolean, collateral: string }) => isSupplied && collateral,
+    ({ symbol, suppliedUsd }: { symbol: string, suppliedUsd: string }) => new Dec(suppliedUsd).mul(aaveAnyGetEmodeMutableProps(data, symbol).liquidationRatio),
+  );
+  payload.borrowedUsd = getAssetsTotal(usedAssets, ({ isBorrowed }: { isBorrowed: boolean }) => isBorrowed, ({ borrowedUsd }: { borrowedUsd: string }) => 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/src/helpers/compoundHelpers/index.ts

@@ -0,0 +1,178 @@
+import Dec from 'decimal.js';
+import { getAssetInfoByAddress } from '@defisaver/tokens';
+import {
+  BaseAdditionalAssetData, CompoundAggregatedPositionData, CompoundMarketData, CompoundV2AssetsData, CompoundV2UsedAssets, CompoundV3AssetData, CompoundV3AssetsData, CompoundV3UsedAssets, 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';
+import { NetworkNumber } from '../../types/common';
+
+export const formatMarketData = (data: any, network: NetworkNumber): CompoundV3AssetData => {
+  const assetInfo = getAssetInfoByAddress(data.tokenAddr, network);
+  const isWETH = assetInfo.symbol === 'WETH';
+  return ({
+    ...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: any, network: NetworkNumber): CompoundV3AssetData & BaseAdditionalAssetData => {
+  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 ({
+    ...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: CompoundV3AssetData & BaseAdditionalAssetData,
+  compPrice: string,
+): {
+  incentiveSupplyApy: string,
+  incentiveBorrowApy: string,
+  incentiveSupplyToken: string,
+  incentiveBorrowToken: string,
+} => {
+  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 = ({
+  usedAssets, assetsData, ...rest
+}: { usedAssets: CompoundV2UsedAssets, assetsData: CompoundV2AssetsData }) => {
+  const payload = {} as CompoundAggregatedPositionData;
+  payload.suppliedUsd = getAssetsTotal(usedAssets, ({ isSupplied }: { isSupplied: boolean }) => isSupplied, ({ suppliedUsd }: { suppliedUsd: string }) => suppliedUsd);
+  payload.suppliedCollateralUsd = getAssetsTotal(usedAssets, ({ isSupplied, collateral }: { isSupplied: boolean, collateral: boolean }) => isSupplied && collateral, ({ suppliedUsd }: { suppliedUsd: string }) => suppliedUsd);
+  payload.borrowedUsd = getAssetsTotal(usedAssets, ({ isBorrowed }: { isBorrowed: boolean }) => isBorrowed, ({ borrowedUsd }: { borrowedUsd: string }) => borrowedUsd);
+  payload.borrowLimitUsd = getAssetsTotal(usedAssets, ({ isSupplied, collateral }: { isSupplied: boolean, collateral: boolean }) => isSupplied && collateral, ({ symbol, suppliedUsd }: { symbol: string, suppliedUsd: string }) => 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 = ({
+  usedAssets, assetsData, network, selectedMarket, ...rest
+}: { usedAssets: CompoundV3UsedAssets, assetsData: CompoundV3AssetsData, network: NetworkNumber, selectedMarket: CompoundMarketData }) => {
+  const payload = {} as CompoundAggregatedPositionData;
+  payload.suppliedUsd = getAssetsTotal(usedAssets, ({ isSupplied }: { isSupplied: boolean }) => isSupplied, ({ suppliedUsd }: { suppliedUsd: string }) => suppliedUsd);
+  payload.suppliedCollateralUsd = getAssetsTotal(usedAssets, ({ isSupplied, collateral }: { isSupplied: boolean, collateral: boolean }) => isSupplied && collateral, ({ suppliedUsd }: { suppliedUsd: string }) => suppliedUsd);
+  payload.borrowedUsd = getAssetsTotal(usedAssets, ({ isBorrowed }: { isBorrowed: boolean }) => isBorrowed, ({ borrowedUsd }: { borrowedUsd: string }) => borrowedUsd);
+  payload.borrowLimitUsd = getAssetsTotal(usedAssets, ({ isSupplied, collateral }: { isSupplied: boolean, collateral: boolean }) => isSupplied && collateral, ({ symbol, suppliedUsd }: { symbol: string, suppliedUsd: string }) => new Dec(suppliedUsd).mul(assetsData[symbol].collateralFactor));
+  payload.liquidationLimitUsd = getAssetsTotal(usedAssets, ({ isSupplied, collateral }: { isSupplied: boolean, collateral: boolean }) => isSupplied && collateral, ({ symbol, suppliedUsd }: { symbol: string, suppliedUsd: string }) => new Dec(suppliedUsd).mul(assetsData[symbol].liquidationRatio));
+  payload.debtTooLow = new Dec(usedAssets[selectedMarket.baseAsset]?.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;
+};