@defisaver/positions-sdk 2.1.136 → 2.1.137-audit-dev

package/esm/markets/euler/index.d.ts

@@ -1,8 +0,0 @@
-import { NetworkNumber } from '../../types/common';
-import { EulerV2Market } from '../../types';
-export declare const eUSDC2: (networkId: NetworkNumber) => EulerV2Market;
-export declare const eWETH2: (networkId: NetworkNumber) => EulerV2Market;
-export declare const EulerV2Markets: (networkId: NetworkNumber) => {
-    readonly "eUSDC-2": EulerV2Market;
-    readonly "eWETH-2": EulerV2Market;
-};

package/esm/markets/euler/index.js

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

package/esm/types/euler.d.ts

@@ -1,153 +0,0 @@
-import { EthAddress, IncentiveData, LeverageType, MMPositionData, NetworkNumber } from './common';
-export declare enum EulerV2Versions {
-    eUSDC2 = "eUSDC-2",
-    eWETH2 = "eWETH-2"
-}
-export declare enum EulerV2VaultType {
-    Escrow = "Escrow",
-    Governed = "Governed",
-    Ungoverned = "Ungoverned"
-}
-export interface EulerV2Market {
-    chainIds: NetworkNumber[];
-    label: string;
-    shortLabel: string;
-    asset: string;
-    value: EulerV2Versions;
-    secondLabel: string;
-    marketAddress: EthAddress;
-}
-export interface EulerV2PositionData extends MMPositionData {
-    ratio: string;
-    minRatio: string;
-    suppliedUsd: string;
-    borrowedUsd: string;
-    borrowLimitUsd: string;
-    incentiveUsd: string;
-    totalInterestUsd: string;
-    isSubscribedToAutomation?: boolean;
-    automationResubscribeRequired?: boolean;
-}
-export interface EulerV2AssetData {
-    vaultAddress: string;
-    vaultSymbol: string;
-    sortIndex?: number;
-    liquidationRatio: string;
-    cash: string;
-    supplyCap: string;
-    assetAddress: string;
-    decimals: string;
-    symbol: string;
-    price: string;
-    borrowCap: string;
-    canBeBorrowed: boolean;
-    canBeSupplied: boolean;
-    supplyIncentives: IncentiveData[];
-    borrowIncentives: IncentiveData[];
-    totalBorrow: string;
-    collateralFactor: string;
-    borrowRate: string;
-    supplyRate: string;
-    utilization: string;
-    governorAdmin: string;
-    vaultType: EulerV2VaultType;
-}
-export interface EulerV2UsedAsset {
-    isSupplied: boolean;
-    isBorrowed: boolean;
-    supplied: string;
-    suppliedUsd: string;
-    borrowed: string;
-    borrowedUsd: string;
-    symbol: string;
-    collateral: boolean;
-    vaultAddress: string;
-}
-export interface EulerV2MarketInfoData {
-    name: string;
-    symbol: string;
-    decimals: string;
-    vaultAddress: string;
-    irm: string;
-    creator: string;
-    governorAdmin: string;
-    unitOfAccount: string;
-    unitOfAccountUsdPrice: string;
-    isInUSD: boolean;
-    oracle: string;
-    collaterals: string[];
-    isEscrow: boolean;
-    isGoverned: boolean;
-    vaultType: EulerV2VaultType;
-}
-export type EulerV2AssetsData = {
-    [key: string]: EulerV2AssetData;
-};
-export type EulerV2UsedAssets = {
-    [key: string]: EulerV2UsedAsset;
-};
-export interface EulerV2CollateralInfo {
-    lltv: string;
-    borrowLtv: string;
-    totalBorrows: string;
-    cash: string;
-    supplyCap: string;
-}
-export interface EulerV2MarketData {
-    name: string;
-    symbol: string;
-    decimals: number;
-    totalSupplyShares: string;
-    cash: string;
-    totalBorrows: string;
-    totalAssets: string;
-    supplyCap: string;
-    borrowCap: string;
-    collaterals: string[];
-    badDebtSocializationEnabled: boolean;
-    unitOfAccount: string;
-    oracle: string;
-    assetPrice: string;
-    interestRate: string;
-    irm: string;
-    creator: string;
-    governorAdmin: string;
-    interestFee: string;
-}
-export interface EulerV2FullMarketData {
-    marketData: EulerV2MarketInfoData;
-    assetsData: EulerV2AssetsData;
-}
-export interface EulerV2AccountData {
-    owner: string;
-    inLockDownMode: boolean;
-    inPermitDisabledMode: boolean;
-    borrowVault: string;
-    borrowAmountInUnit: string;
-    collaterals: string[];
-    collateralAmountsInUnit: string[];
-}
-export interface EulerV2AggregatedPositionData {
-    suppliedUsd: string;
-    suppliedCollateralUsd: string;
-    borrowedUsd: string;
-    borrowLimitUsd: string;
-    liquidationLimitUsd: string;
-    leftToBorrowUsd: string;
-    ratio: string;
-    collRatio: string;
-    netApy: string;
-    incentiveUsd: string;
-    totalInterestUsd: string;
-    liqRatio: string;
-    liqPercent: string;
-    leveragedType: LeverageType;
-    leveragedAsset?: string;
-    currentVolatilePairRatio?: string;
-    liquidationPrice?: string;
-    minRatio: string;
-    minDebt: string;
-    minCollRatio: string;
-    collLiquidationRatio: string;
-    exposure: string;
-}

package/esm/types/euler.js

@@ -1,11 +0,0 @@
-export var EulerV2Versions;
-(function (EulerV2Versions) {
-    EulerV2Versions["eUSDC2"] = "eUSDC-2";
-    EulerV2Versions["eWETH2"] = "eWETH-2";
-})(EulerV2Versions || (EulerV2Versions = {}));
-export var EulerV2VaultType;
-(function (EulerV2VaultType) {
-    EulerV2VaultType["Escrow"] = "Escrow";
-    EulerV2VaultType["Governed"] = "Governed";
-    EulerV2VaultType["Ungoverned"] = "Ungoverned";
-})(EulerV2VaultType || (EulerV2VaultType = {}));

package/src/eulerV2/index.ts

@@ -1,331 +0,0 @@
-import Dec from 'decimal.js';
-import { assetAmountInEth, getAssetInfoByAddress } from '@defisaver/tokens';
-import { Client } from 'viem';
-import { getStakingApy, STAKING_ASSETS } from '../staking';
-import {
-  compareAddresses,
-  getEthAmountForDecimals,
-  isMaxUint,
-  wethToEth,
-  wethToEthByAddress,
-} from '../services/utils';
-import {
-  EulerV2AssetData,
-  EulerV2AssetsData,
-  EulerV2FullMarketData,
-  EulerV2Market,
-  EulerV2MarketInfoData,
-  EulerV2PositionData,
-  EulerV2UsedAssets,
-  EulerV2VaultType,
-  EthAddress,
-  EthereumProvider,
-  IncentiveKind,
-  NetworkNumber,
-} from '../types';
-import {
-  getEulerV2AggregatedData,
-  getEulerV2BorrowRate,
-  getEulerV2SupplyRate,
-  getUtilizationRate,
-} from '../helpers/eulerHelpers';
-import { ZERO_ADDRESS } from '../constants';
-import { EulerV2ViewContractViem } from '../contracts';
-import { getViemProvider } from '../services/viem';
-
-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 (provider: Client, network: NetworkNumber, selectedMarket: EulerV2Market): Promise<EulerV2FullMarketData> => {
-  const contract = EulerV2ViewContractViem(provider, network);
-
-  const data = await contract.read.getVaultInfoFull([selectedMarket.marketAddress]);
-  const isInUSD = compareAddresses(UnitOfAccountUSD, data.unitOfAccount);
-
-  const usdPrice = getEthAmountForDecimals(data.unitOfAccountInUsd.toString(), 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.toString();
-    const assetInfo = getAssetInfoByAddress(collateral.assetAddr);
-    const borrowRate = getEulerV2BorrowRate(collateral.interestRate.toString());
-    const utilizationRate = getUtilizationRate(collateral.totalBorrows.toString(), new Dec(collateral.totalBorrows.toString()).plus(collateral.cash.toString()).toString());
-
-    const supplyRate = getEulerV2SupplyRate(borrowRate, utilizationRate, collateral.interestFee.toString());
-
-    const isEscrow = collateral.isEscrowed;
-    const isGoverned = !compareAddresses(collateral.governorAdmin, ZERO_ADDRESS);
-
-    const vaultType = isEscrow
-      ? EulerV2VaultType.Escrow
-      : (
-        isGoverned ? EulerV2VaultType.Governed : EulerV2VaultType.Ungoverned
-      );
-    return ({
-      vaultAddress: collateral.vaultAddr,
-      assetAddress: wethToEthByAddress(collateral.assetAddr),
-      symbol: wethToEth(assetInfo.symbol),
-      vaultSymbol: collateral.vaultSymbol,
-      name: collateral.name,
-      vaultType,
-      decimals,
-      liquidationRatio: new Dec(collateral.liquidationLTV).div(10_000).toString(),
-      collateralFactor: new Dec(collateral.borrowLTV).div(10_000).toString(),
-      totalBorrow: getEthAmountForDecimals(collateral.totalBorrows.toString(), decimals), // parse
-      cash: getEthAmountForDecimals(collateral.cash.toString(), decimals),
-      supplyCap: isMaxUint(collateral.supplyCap.toString()) ? collateral.supplyCap.toString() : getEthAmountForDecimals(collateral.supplyCap.toString(), decimals),
-      borrowCap: '0',
-      price: isInUSD ? assetAmountInEth(collateral.assetPriceInUnit.toString()) : new Dec(assetAmountInEth(collateral.assetPriceInUnit.toString())).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(),
-      governorAdmin: collateral.governorAdmin,
-      supplyIncentives: [],
-      borrowIncentives: [],
-    });
-  });
-  for (const coll of colls) {
-    if (STAKING_ASSETS.includes(coll.symbol)) {
-      coll.supplyIncentives.push({
-        apy: await getStakingApy(coll.symbol),
-        token: coll.symbol,
-        incentiveKind: IncentiveKind.Staking,
-        description: `Native ${coll.symbol} yield.`,
-      });
-    }
-  }
-  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.toString();
-
-  // (1 + SPY/10**27) ** secondsPerYear - 1
-
-  const interestRate = data.interestRate.toString();
-
-  const borrowRate = getEulerV2BorrowRate(interestRate);
-
-  const utilizationRate = getUtilizationRate(data.totalBorrows.toString(), data.totalAssets.toString());
-  const supplyRate = getEulerV2SupplyRate(borrowRate, utilizationRate, data.interestFee.toString());
-
-  const marketAsset = {
-    assetAddress: data.assetAddr,
-    vaultAddress: data.vaultAddr,
-    symbol: selectedMarket.asset,
-    vaultSymbol: selectedMarket.shortLabel,
-    decimals,
-    totalBorrow: getEthAmountForDecimals(data.totalBorrows.toString(), decimals), // parse
-    cash: getEthAmountForDecimals(data.cash.toString(), decimals),
-    supplyCap: isMaxUint(data.supplyCap.toString()) ? data.supplyCap.toString() : getEthAmountForDecimals(data.supplyCap.toString(), decimals),
-    borrowCap: isMaxUint(data.supplyCap.toString()) ? data.borrowCap.toString() : getEthAmountForDecimals(data.borrowCap.toString(), decimals),
-    price: isInUSD ? assetAmountInEth(data.assetPriceInUnit.toString()) : new Dec(assetAmountInEth(data.assetPriceInUnit.toString())).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(),
-    governorAdmin: data.governorAdmin,
-    vaultType,
-    name: data.name,
-    supplyIncentives: [],
-    borrowIncentives: [],
-  };
-
-  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.toString(),
-    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 getEulerV2MarketsData = async (
-  provider: EthereumProvider,
-  network: NetworkNumber,
-  selectedMarket: EulerV2Market,
-): Promise<EulerV2FullMarketData> => _getEulerV2MarketsData(getViemProvider(provider, network), network, selectedMarket);
-
-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,
-  addressSpaceTakenByAnotherAccount: false,
-  exposure: 'N/A',
-};
-
-export const _getEulerV2AccountData = async (
-  provider: Client,
-  network: NetworkNumber,
-  addressForPosition: EthAddress,
-  ownerAddress: EthAddress,
-  extractedState: ({
-    selectedMarket: EulerV2Market,
-    assetsData: EulerV2AssetsData,
-    marketData: EulerV2MarketInfoData,
-  }),
-): Promise<EulerV2PositionData> => {
-  if (!addressForPosition) throw new Error('No address provided');
-
-  const {
-    selectedMarket, assetsData, marketData,
-  } = extractedState;
-
-  let payload = {
-    ...EMPTY_EULER_V2_DATA,
-    lastUpdated: Date.now(),
-  };
-
-  const isInUSD = marketData.isInUSD;
-
-  const parsingDecimals = isInUSD ? 18 : getAssetInfoByAddress(marketData.unitOfAccount).decimals;
-  const contract = EulerV2ViewContractViem(provider, network);
-
-  const loanData = await contract.read.getUserData([addressForPosition]);
-  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),
-      addressSpaceTakenByAnotherAccount: !compareAddresses(loanData.owner, ownerAddress) && !compareAddresses(loanData.owner, ZERO_ADDRESS),
-    };
-  } else {
-    payload = {
-      ...payload,
-      borrowVault: loanData.borrowVault,
-      borrowAmountInUnit: loanData.borrowAmountInUnit.toString(),
-      inLockDownMode: loanData.inLockDownMode,
-      inPermitDisabledMode: loanData.inPermitDisabledMode,
-      addressSpaceTakenByAnotherAccount: !compareAddresses(loanData.owner, ownerAddress) && !compareAddresses(loanData.owner, ZERO_ADDRESS),
-    };
-
-    const borrowedInUnit = getEthAmountForDecimals(loanData.borrowAmountInUnit.toString(), parsingDecimals);
-    const borrowedInAsset = getEthAmountForDecimals(loanData.borrowAmountInAsset.toString(), 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.toString(), parsingDecimals);
-    const suppliedInAsset = getEthAmountForDecimals(collateral.collateralAmountInAsset.toString(), collInfo.decimals);
-    const collateralAmountInUSD = getEthAmountForDecimals(collateral.collateralAmountInUSD.toString(), 18);
-    usedAssets[key] = {
-      ...EMPTY_USED_ASSET,
-      collateral: true,
-      isSupplied: !new Dec(suppliedInAsset).eq(0),
-      supplied: suppliedInAsset,
-      suppliedUsd: collateralAmountInUSD,
-      vaultAddress: collateral.collateralVault,
-      symbol: collInfo.symbol,
-    };
-  });
-
-  payload = {
-    ...payload,
-    usedAssets,
-    ...getEulerV2AggregatedData({
-      usedAssets, assetsData, network,
-    }),
-  };
-
-  return payload;
-};
-
-export const getEulerV2AccountData = async (
-  provider: EthereumProvider,
-  network: NetworkNumber,
-  addressForPosition: EthAddress,
-  ownerAddress: EthAddress,
-  extractedState: ({
-    selectedMarket: EulerV2Market,
-    assetsData: EulerV2AssetsData,
-    marketData: EulerV2MarketInfoData,
-  }),
-): Promise<EulerV2PositionData> => _getEulerV2AccountData(getViemProvider(provider, network), network, addressForPosition, ownerAddress, extractedState);