@defisaver/positions-sdk 0.0.166-dev → 0.0.166

package/src/eulerV2/index.ts

@@ -1,286 +0,0 @@
-import Web3 from 'web3';
-import Dec from 'decimal.js';
-import { assetAmountInEth, getAssetInfoByAddress } from '@defisaver/tokens';
-import { NetworkNumber } from '../types/common';
-import { getStakingApy, STAKING_ASSETS } from '../staking';
-import { compareAddresses, getEthAmountForDecimals, isMaxuint } from '../services/utils';
-import {
-  EulerV2AssetData,
-  EulerV2AssetsData,
-  EulerV2FullMarketData,
-  EulerV2Market,
-  EulerV2MarketInfoData,
-  EulerV2PositionData,
-  EulerV2UsedAssets,
-  EulerV2VaultType,
-} from '../types';
-import {
-  getEulerV2AggregatedData,
-  getEulerV2BorrowRate,
-  getEulerV2SupplyRate,
-  getUtilizationRate,
-} from '../helpers/eulerHelpers';
-import { ZERO_ADDRESS } from '../constants';
-import { EulerV2ViewContract } from '../contracts';
-
-export const EMPTY_USED_ASSET = {
-  isSupplied: false,
-  isBorrowed: false,
-  supplied: '0',
-  suppliedUsd: '0',
-  borrowed: '0',
-  borrowedUsd: '0',
-  symbol: '',
-  collateral: false,
-  vaultAddress: '',
-};
-
-const UnitOfAccountUSD = '0x0000000000000000000000000000000000000348';
-
-export const getEulerV2MarketsData = async (web3: Web3, network: NetworkNumber, selectedMarket: EulerV2Market, defaultWeb3: Web3): Promise<EulerV2FullMarketData> => {
-  const contract = EulerV2ViewContract(web3, network);
-
-  const data = await contract.methods.getVaultInfoFull(selectedMarket.marketAddress).call();
-  const isInUSD = compareAddresses(UnitOfAccountUSD, data.unitOfAccount);
-
-  const usdPrice = getEthAmountForDecimals(data.unitOfAccountInUsd, 8);
-
-  // parse collateral tokens
-  // imma use address as key for assetsData because there can be more collateral vaults with the same name
-  const colls: EulerV2AssetData[] = data.collaterals.map((collateral) => {
-    const decimals = collateral.decimals;
-    const assetInfo = getAssetInfoByAddress(collateral.assetAddr);
-    const borrowRate = getEulerV2BorrowRate(collateral.interestRate);
-    const utilizationRate = getUtilizationRate(collateral.totalBorrows, new Dec(collateral.totalBorrows).plus(collateral.cash).toString());
-
-    const supplyRate = getEulerV2SupplyRate(borrowRate, utilizationRate, collateral.interestFee);
-    return ({
-      vaultAddress: collateral.vaultAddr,
-      assetAddress: collateral.assetAddr,
-      symbol: assetInfo.symbol,
-      vaultSymbol: collateral.vaultSymbol,
-      decimals,
-      liquidationRatio: new Dec(collateral.liquidationLTV).div(10_000).toString(),
-      collateralFactor: new Dec(collateral.borrowLTV).div(10_000).toString(),
-      totalBorrow: getEthAmountForDecimals(collateral.totalBorrows, decimals), // parse
-      cash: getEthAmountForDecimals(collateral.cash, decimals),
-      supplyCap: isMaxuint(collateral.supplyCap) ? collateral.supplyCap : getEthAmountForDecimals(collateral.supplyCap, decimals),
-      borrowCap: '0',
-      price: isInUSD ? assetAmountInEth(collateral.assetPriceInUnit) : new Dec(assetAmountInEth(collateral.assetPriceInUnit)).mul(usdPrice).toString(), // 1e18 -> price in unitOfAccount (so it could be USD or any other token)
-      canBeBorrowed: false,
-      canBeSupplied: true,
-      borrowRate,
-      supplyRate,
-      utilization: new Dec(utilizationRate).mul(100).toString(),
-    });
-  });
-  for (const coll of colls) {
-    if (STAKING_ASSETS.includes(coll.symbol)) {
-      coll.incentiveSupplyApy = await getStakingApy(coll.symbol, defaultWeb3);
-      coll.incentiveSupplyToken = coll.symbol;
-    }
-  }
-  const isEscrow = data.collaterals.length === 0;
-  const isGoverned = !compareAddresses(data.governorAdmin, ZERO_ADDRESS);
-
-  const vaultType = isEscrow ? EulerV2VaultType.Escrow : (
-    isGoverned ? EulerV2VaultType.Governed : EulerV2VaultType.Ungoverned
-  );
-  const decimals = data.decimals;
-
-  // (1 + SPY/10**27) ** secondsPerYear - 1
-
-  const interestRate = data.interestRate;
-
-  const borrowRate = getEulerV2BorrowRate(interestRate);
-
-  const utilizationRate = getUtilizationRate(data.totalBorrows, data.totalAssets);
-  const supplyRate = getEulerV2SupplyRate(borrowRate, utilizationRate, data.interestFee);
-
-  const marketAsset = {
-    assetAddress: data.assetAddr,
-    vaultAddress: data.vaultAddr,
-    symbol: selectedMarket.asset,
-    vaultSymbol: selectedMarket.shortLabel,
-    decimals,
-    totalBorrow: getEthAmountForDecimals(data.totalBorrows, decimals), // parse
-    cash: getEthAmountForDecimals(data.cash, decimals),
-    supplyCap: isMaxuint(data.supplyCap) ? data.supplyCap : getEthAmountForDecimals(data.supplyCap, decimals),
-    borrowCap: isMaxuint(data.supplyCap) ? data.borrowCap : getEthAmountForDecimals(data.borrowCap, decimals),
-    price: isInUSD ? assetAmountInEth(data.assetPriceInUnit) : new Dec(assetAmountInEth(data.assetPriceInUnit)).mul(usdPrice).toString(), // 1e18 -> price in unitOfAccount (so it could be USD or any other token)
-    sortIndex: 0,
-    canBeBorrowed: true,
-    canBeSupplied: false,
-    borrowRate,
-    supplyRate,
-    collateralFactor: '0',
-    liquidationRatio: '0',
-    utilization: new Dec(utilizationRate).mul(100).toString(),
-  };
-
-  const assetsData: EulerV2AssetsData = {
-    [data.vaultAddr.toLowerCase()]: marketAsset,
-  };
-
-  colls
-    .sort((coll1, coll2) => {
-      const aMarket = new Dec(coll1.price).times(coll1.totalBorrow).toString();
-      const bMarket = new Dec(coll2.price).times(coll2.totalBorrow).toString();
-
-      return new Dec(bMarket).minus(aMarket).toNumber();
-    })
-    .forEach((market, i) => {
-      assetsData[market.vaultAddress.toLowerCase()] = { ...market, sortIndex: i + 1 };
-    });
-
-  const marketData: EulerV2MarketInfoData = {
-    name: data.name,
-    symbol: data.symbol,
-    decimals: data.decimals,
-    irm: data.irm,
-    creator: data.creator,
-    governorAdmin: data.governorAdmin,
-    unitOfAccount: data.unitOfAccount,
-    unitOfAccountUsdPrice: usdPrice,
-    isInUSD,
-    oracle: data.oracle,
-    collaterals: data.collaterals.map((collateral) => collateral.vaultAddr),
-    isEscrow,
-    isGoverned,
-    vaultType,
-    vaultAddress: data.vaultAddr,
-  };
-
-  return {
-    marketData,
-    assetsData,
-  };
-};
-
-// export const getEulerV2AccountBalances = async (
-//     web3: Web3,
-//     network: NetworkNumber,
-//     selectedMarket: EulerV2MarketData
-// ): Promise<> => {
-//
-// }
-
-export const EMPTY_EULER_V2_DATA = {
-  usedAssets: {},
-  suppliedUsd: '0',
-  borrowedUsd: '0',
-  borrowLimitUsd: '0',
-  leftToBorrowUsd: '0',
-  ratio: '0',
-  minRatio: '0',
-  netApy: '0',
-  incentiveUsd: '0',
-  totalInterestUsd: '0',
-  isSubscribedToAutomation: false,
-  automationResubscribeRequired: false,
-  borrowVault: '',
-  borrowAmountInUnit: '0',
-  inLockDownMode: false,
-  inPermitDisabledMode: false,
-  lastUpdated: Date.now(),
-  hasBorrowInDifferentVault: false,
-};
-
-export const getEulerV2AccountData = async (
-  web3: Web3,
-  network: NetworkNumber,
-  address: string,
-  extractedState: ({
-    selectedMarket: EulerV2Market,
-    assetsData: EulerV2AssetsData,
-    marketData: EulerV2MarketInfoData,
-  }),
-): Promise<EulerV2PositionData> => {
-  if (!address) throw new Error('No address provided');
-
-  const {
-    selectedMarket, assetsData, marketData,
-  } = extractedState;
-
-  let payload = {
-    ...EMPTY_EULER_V2_DATA,
-    lastUpdated: Date.now(),
-  };
-
-  const isInUSD = marketData.isInUSD;
-
-  // TODO: maybe not the best practice to get decimals from tokens package
-  const parsingDecimals = isInUSD ? 18 : getAssetInfoByAddress(marketData.unitOfAccount).decimals;
-  const contract = EulerV2ViewContract(web3, network);
-
-  const loanData = await contract.methods.getUserData(address).call();
-  const usedAssets: EulerV2UsedAssets = {};
-
-  // there is no user position check for a specific market, only global check
-  // but we need to make sure it works for the UI and show position only for the selected market
-  if (!compareAddresses(loanData.borrowVault, selectedMarket.marketAddress)) {
-    payload = {
-      ...payload,
-      borrowVault: ZERO_ADDRESS,
-      borrowAmountInUnit: '0',
-      inLockDownMode: false,
-      inPermitDisabledMode: false,
-      hasBorrowInDifferentVault: !compareAddresses(loanData.borrowVault, ZERO_ADDRESS),
-    };
-  } else {
-    payload = {
-      ...payload,
-      borrowVault: loanData.borrowVault,
-      borrowAmountInUnit: loanData.borrowAmountInUnit,
-      inLockDownMode: loanData.inLockDownMode,
-      inPermitDisabledMode: loanData.inPermitDisabledMode,
-      hasBorrowInDifferentVault: false,
-    };
-
-    const borrowedInUnit = getEthAmountForDecimals(loanData.borrowAmountInUnit, parsingDecimals);
-    const borrowedInAsset = getEthAmountForDecimals(loanData.borrowAmountInAsset, marketData.decimals);
-    const borrowVault = loanData.borrowVault;
-
-    if (borrowVault && !compareAddresses(ZERO_ADDRESS, borrowVault) && borrowedInUnit) {
-      const borrowInfo = assetsData[borrowVault.toLowerCase()];
-      usedAssets[borrowVault.toLowerCase()] = {
-        ...EMPTY_USED_ASSET,
-        isBorrowed: true,
-        borrowed: borrowedInAsset,
-        borrowedUsd: isInUSD ? borrowedInUnit : new Dec(borrowedInUnit).mul(marketData.unitOfAccountUsdPrice).toString(),
-        vaultAddress: loanData.borrowVault,
-        symbol: borrowInfo.symbol,
-      };
-    }
-  }
-
-  loanData.collaterals.forEach((collateral, i) => {
-    const key = collateral.collateralVault.toLowerCase();
-    const collInfo = assetsData[key];
-
-    if (!collInfo || !marketData.collaterals.map(a => a.toLowerCase()).includes(key)) return; // this is a token supplied but not being used as a collateral for the market
-
-    const suppliedInUnit = getEthAmountForDecimals(collateral.collateralAmountInUnit, parsingDecimals);
-    const suppliedInAsset = getEthAmountForDecimals(collateral.collateralAmountInAsset, collInfo.decimals);
-    const collateralAmountInUSD = getEthAmountForDecimals(collateral.collateralAmountInUSD, 18);
-    usedAssets[key] = {
-      ...EMPTY_USED_ASSET,
-      collateral: true,
-      isSupplied: true,
-      supplied: suppliedInAsset,
-      suppliedUsd: collateralAmountInUSD,
-      vaultAddress: collateral.collateralVault,
-      symbol: collInfo.symbol,
-    };
-  });
-
-  payload = {
-    ...payload,
-    usedAssets,
-    ...getEulerV2AggregatedData({
-      usedAssets, assetsData, network,
-    }),
-  };
-
-  return payload;
-};

package/src/helpers/eulerHelpers/index.ts

@@ -1,231 +0,0 @@
-import Dec from 'decimal.js';
-import Web3 from 'web3';
-import { assetAmountInWei } from '@defisaver/tokens';
-import {
-  EthAddress, NetworkNumber,
-} from '../../types/common';
-import {
-  calcLeverageLiqPrice, getAssetsTotal, STABLE_ASSETS,
-} from '../../moneymarket';
-import { calculateInterestEarned } from '../../staking';
-import {
-  EulerV2AggregatedPositionData,
-  EulerV2AssetsData,
-  EulerV2Market,
-  EulerV2UsedAssets,
-} from '../../types';
-import { EulerV2ViewContract } from '../../contracts';
-import { borrowOperations } from '../../constants';
-import { multicall } from '../../multicall';
-
-export const isLeveragedPos = (usedAssets: EulerV2UsedAssets, dustLimit = 5) => {
-  let borrowUnstable = 0;
-  let supplyStable = 0;
-  let borrowStable = 0;
-  let supplyUnstable = 0;
-  let longAsset = '';
-  let shortAsset = '';
-  let leverageAssetVault = '';
-  Object.values(usedAssets).forEach(({
-    symbol, suppliedUsd, borrowedUsd, collateral, vaultAddress,
-  }) => {
-    const isSupplied = (+suppliedUsd) > dustLimit; // ignore dust like <limit leftover supply
-    const isBorrowed = (+borrowedUsd) > dustLimit; // ignore dust like <limit leftover supply
-    if (isSupplied && STABLE_ASSETS.includes(symbol) && collateral) supplyStable += 1;
-    if (isBorrowed && STABLE_ASSETS.includes(symbol)) borrowStable += 1;
-    if (isBorrowed && !STABLE_ASSETS.includes(symbol)) {
-      borrowUnstable += 1;
-      shortAsset = symbol;
-      leverageAssetVault = vaultAddress;
-    }
-    if (isSupplied && !STABLE_ASSETS.includes(symbol) && collateral) {
-      supplyUnstable += 1;
-      longAsset = symbol;
-      leverageAssetVault = vaultAddress;
-    }
-  });
-  const isLong = borrowStable > 0 && borrowUnstable === 0 && supplyUnstable === 1 && supplyStable === 0;
-  const isShort = supplyStable > 0 && supplyUnstable === 0 && borrowUnstable === 1 && borrowStable === 0;
-  // lsd -> liquid staking derivative
-  const isLsdLeveraged = supplyUnstable === 1 && borrowUnstable === 1 && shortAsset === 'ETH' && ['stETH', 'wstETH', 'cbETH', 'rETH'].includes(longAsset);
-  if (isLong) {
-    return {
-      leveragedType: 'long',
-      leveragedAsset: longAsset,
-      leveragedVault: leverageAssetVault,
-    };
-  }
-  if (isShort) {
-    return {
-      leveragedType: 'short',
-      leveragedAsset: shortAsset,
-      leveragedVault: leverageAssetVault,
-    };
-  }
-  if (isLsdLeveraged) {
-    return {
-      leveragedType: 'lsd-leverage',
-      leveragedAsset: longAsset,
-      leveragedVault: leverageAssetVault,
-    };
-  }
-  return {
-    leveragedType: '',
-    leveragedAsset: '',
-    leveragedVault: '',
-  };
-};
-
-export const calculateNetApy = (usedAssets: EulerV2UsedAssets, assetsData: EulerV2AssetsData) => {
-  const sumValues = Object.values(usedAssets).reduce((_acc, usedAsset) => {
-    const acc = { ..._acc };
-    const assetData = assetsData[usedAsset.vaultAddress.toLowerCase()];
-
-    if (usedAsset.isSupplied) {
-      const amount = usedAsset.suppliedUsd;
-      acc.suppliedUsd = new Dec(acc.suppliedUsd).add(amount).toString();
-      const rate = assetData.supplyRate;
-      const supplyInterest = calculateInterestEarned(amount, rate as string, 'year', true);
-      acc.supplyInterest = new Dec(acc.supplyInterest).add(supplyInterest.toString()).toString();
-    }
-
-    if (usedAsset.isBorrowed) {
-      const amount = usedAsset.borrowedUsd;
-      acc.borrowedUsd = new Dec(acc.borrowedUsd).add(amount).toString();
-      const rate = assetData.borrowRate;
-      const borrowInterest = calculateInterestEarned(amount, rate as string, 'year', true);
-      acc.borrowInterest = new Dec(acc.borrowInterest).sub(borrowInterest.toString()).toString();
-    }
-
-    return acc;
-  }, {
-    borrowInterest: '0', supplyInterest: '0', incentiveUsd: '0', borrowedUsd: '0', suppliedUsd: '0',
-  });
-
-  const {
-    borrowedUsd, suppliedUsd, borrowInterest, supplyInterest, incentiveUsd,
-  } = sumValues;
-
-  const totalInterestUsd = new Dec(borrowInterest).add(supplyInterest).add(incentiveUsd).toString();
-  const balance = new Dec(suppliedUsd).sub(borrowedUsd);
-  const netApy = new Dec(totalInterestUsd).div(balance).times(100).toString();
-
-  return { netApy, totalInterestUsd, incentiveUsd };
-};
-
-export const getEulerV2AggregatedData = ({
-  usedAssets, assetsData, network, ...rest
-}: { usedAssets: EulerV2UsedAssets, assetsData: EulerV2AssetsData, network: NetworkNumber }) => {
-  const payload = {} as EulerV2AggregatedPositionData;
-  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, ({ vaultAddress, suppliedUsd }: { vaultAddress: string, suppliedUsd: string }) => new Dec(suppliedUsd).mul(assetsData[vaultAddress.toLowerCase()].collateralFactor));
-  payload.liquidationLimitUsd = getAssetsTotal(usedAssets, ({ isSupplied, collateral }: { isSupplied: boolean, collateral: boolean }) => isSupplied && collateral, ({ vaultAddress, suppliedUsd }: { vaultAddress: string, suppliedUsd: string }) => new Dec(suppliedUsd).mul(assetsData[vaultAddress.toLowerCase()].liquidationRatio));
-  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();
-  const { leveragedType, leveragedAsset, leveragedVault } = isLeveragedPos(usedAssets);
-  payload.leveragedType = leveragedType;
-  if (leveragedType !== '') {
-    payload.leveragedAsset = leveragedAsset;
-    let assetPrice = assetsData[leveragedVault.toLowerCase()].price;
-    if (leveragedType === 'lsd-leverage') {
-      const ethAsset = Object.values(assetsData).find((asset) => ['WETH', 'ETH'].includes(asset.symbol));
-      if (ethAsset) {
-        payload.leveragedLsdAssetRatio = new Dec(assetsData[leveragedVault.toLowerCase()].price).div(ethAsset.price).toString();
-        assetPrice = new Dec(assetPrice).div(ethAsset.price).toString();
-      }
-    }
-    payload.liquidationPrice = calcLeverageLiqPrice(leveragedType, assetPrice, payload.borrowedUsd, payload.liquidationLimitUsd);
-  }
-  return payload;
-};
-
-export const getEulerV2BorrowRate = (interestRate: string) => {
-  const _interestRate = new Dec(interestRate).div(1e27).toString();
-  const secondsPerYear = 31556953;
-  const a = new Dec(1).plus(_interestRate).pow(secondsPerYear - 1).toString();
-  return new Dec(new Dec(a).minus(1)).mul(100).toString();
-};
-
-export const getUtilizationRate = (totalBorrows: string, totalAssets: string) => new Dec(totalBorrows).div(totalAssets).toString();
-
-export const getEulerV2SupplyRate = (borrowRate: string, utilizationRate: string, _interestFee: string) => {
-  const interestFee = new Dec(_interestFee).div(10000);
-  const fee = new Dec(1).minus(interestFee);
-  return new Dec(borrowRate).mul(utilizationRate).mul(fee).toString();
-};
-
-const getLiquidityChanges = (action: string, amount: string, isBorrowOperation: boolean) => {
-  let liquidityAdded;
-  let liquidityRemoved;
-  if (isBorrowOperation) {
-    liquidityAdded = action === 'payback' ? amount : '0';
-    liquidityRemoved = action === 'borrow' ? amount : '0';
-  } else {
-    liquidityAdded = action === 'collateral' ? amount : '0';
-    liquidityRemoved = action === 'withdraw' ? amount : '0';
-  }
-  return { liquidityAdded, liquidityRemoved };
-};
-
-export const getApyAfterValuesEstimationEulerV2 = async (actions: { action: string, amount: string, asset: string, vaultAddress: EthAddress }[], web3: Web3, network: NetworkNumber) => {
-  const eulerV2ViewContract = EulerV2ViewContract(web3, network);
-  const multicallData: any[] = [];
-  const apyAfterValuesEstimationParams: any[] = [];
-  actions.forEach(({
-    action, amount, asset, vaultAddress,
-  }) => {
-    const amountInWei = assetAmountInWei(amount, asset);
-    const isBorrowOperation = borrowOperations.includes(action);
-    const { liquidityAdded, liquidityRemoved } = getLiquidityChanges(action, amountInWei, isBorrowOperation);
-    apyAfterValuesEstimationParams.push([
-      vaultAddress,
-      borrowOperations.includes(action),
-      liquidityAdded,
-      liquidityRemoved,
-    ]);
-    multicallData.push({
-      target: eulerV2ViewContract.options.address,
-      abiItem: eulerV2ViewContract.options.jsonInterface.find(({ name }) => name === 'getVaultInfoFull'),
-      params: [vaultAddress],
-    });
-  });
-  multicallData.push({
-    target: eulerV2ViewContract.options.address,
-    abiItem: eulerV2ViewContract.options.jsonInterface.find(({ name }) => name === 'getApyAfterValuesEstimation'),
-    params: [apyAfterValuesEstimationParams],
-  });
-  const multicallRes = await multicall(multicallData, web3, network);
-  const numOfActions = actions.length;
-  const data: any = {};
-  for (let i = 0; i < numOfActions; i += 1) {
-    const _interestRate = multicallRes[numOfActions].estimatedBorrowRates[i];
-    const vaultInfo = multicallRes[i][0];
-    const decimals = vaultInfo.decimals;
-    const borrowRate = getEulerV2BorrowRate(_interestRate);
-
-    const amount = new Dec(actions[i].amount).mul(10 ** decimals).toString();
-    const action = actions[i].action;
-    const isBorrowOperation = borrowOperations.includes(action);
-    const { liquidityAdded, liquidityRemoved } = getLiquidityChanges(action, amount, isBorrowOperation);
-
-    const totalBorrows = new Dec(vaultInfo.totalBorrows).add(isBorrowOperation ? liquidityRemoved : '0').sub(isBorrowOperation ? liquidityAdded : '0').toString();
-    const totalAssets = new Dec(vaultInfo.totalAssets).add(isBorrowOperation ? '0' : liquidityAdded).sub(isBorrowOperation ? '0' : liquidityRemoved).toString();
-    const utilizationRate = getUtilizationRate(totalBorrows, totalAssets);
-    data[vaultInfo.vaultAddr.toLowerCase()] = {
-      borrowRate,
-      supplyRate: getEulerV2SupplyRate(borrowRate, utilizationRate, vaultInfo.interestFee),
-    };
-  }
-  return data;
-};

package/src/markets/euler/index.ts

@@ -1,38 +0,0 @@
-import { NetworkNumber } from '../../types/common';
-import { EulerV2Market, EulerV2Versions } from '../../types';
-
-export const eUSDC2 = (networkId: NetworkNumber): EulerV2Market => ({
-  chainIds: [NetworkNumber.Eth],
-  label: 'Euler Prime USDC',
-  shortLabel: 'eUSDC-2',
-  value: EulerV2Versions.eUSDC2,
-  asset: 'USDC',
-  secondLabel: 'Market',
-  marketAddress: '0x797DD80692c3b2dAdabCe8e30C07fDE5307D48a9',
-});
-
-export const eUSDC8 = (networkId: NetworkNumber): EulerV2Market => ({
-  chainIds: [NetworkNumber.Eth],
-  label: 'Stablecoin Maxi USDC',
-  shortLabel: 'eUSDC-8',
-  value: EulerV2Versions.eUSDC8,
-  asset: 'USDC',
-  secondLabel: 'Market',
-  marketAddress: '0xce45EF0414dE3516cAF1BCf937bF7F2Cf67873De',
-});
-
-export const eWETH2 = (networkId: NetworkNumber): EulerV2Market => ({
-  chainIds: [NetworkNumber.Eth],
-  label: 'Euler Prime WETH',
-  shortLabel: 'eWETH-2',
-  value: EulerV2Versions.eWETH2,
-  asset: 'WETH',
-  secondLabel: 'Market',
-  marketAddress: '0xD8b27CF359b7D15710a5BE299AF6e7Bf904984C2',
-});
-
-export const EulerV2Markets = (networkId: NetworkNumber) => ({
-  [EulerV2Versions.eUSDC2]: eUSDC2(networkId),
-  [EulerV2Versions.eUSDC8]: eUSDC8(networkId),
-  [EulerV2Versions.eWETH2]: eWETH2(networkId),
-}) as const;