@defisaver/positions-sdk 0.0.199 → 0.0.201-fluid-dev

package/src/fluid/index.ts

@@ -0,0 +1,220 @@
+import Web3 from 'web3';
+import Dec from 'decimal.js';
+import { getAssetInfo, getAssetInfoByAddress } from '@defisaver/tokens';
+import { EthAddress, NetworkNumber } from '../types/common';
+import {
+  FluidAggregatedVaultData,
+  FluidAssetData, FluidAssetsData,
+  FluidMarketData,
+  FluidMarketInfo,
+  FluidUsedAsset,
+  FluidUsedAssets,
+  FluidVaultData,
+  FluidVaultType, InnerFluidMarketData,
+} from '../types';
+import { FluidViewContract } from '../contracts';
+import { getEthAmountForDecimals } from '../services/utils';
+import { getFluidAggregatedData } from '../helpers/fluidHelpers';
+import { FluidView } from '../types/contracts/generated';
+
+export const EMPTY_USED_ASSET = {
+  isSupplied: false,
+  isBorrowed: false,
+  supplied: '0',
+  suppliedUsd: '0',
+  borrowed: '0',
+  borrowedUsd: '0',
+  symbol: '',
+  collateral: false,
+};
+
+const parseVaultType = (vaultType: number) => {
+  switch (vaultType) {
+    case 10000: return FluidVaultType.T1;
+    case 20000: return FluidVaultType.T2;
+    case 30000: return FluidVaultType.T3;
+    case 40000: return FluidVaultType.T4;
+    default: return FluidVaultType.Unknown;
+  }
+};
+
+const parseMarketData = (data: FluidView.VaultDataStructOutputStruct) => {
+  const collAsset = getAssetInfoByAddress(data.supplyToken0);
+  const debtAsset = getAssetInfoByAddress(data.borrowToken0);
+
+  const collAssetData: FluidAssetData = {
+    symbol: collAsset.symbol,
+    address: collAsset.address,
+    price: getEthAmountForDecimals(data.priceOfSupplyToken0InUSD, 8),
+    totalSupply: data.totalSupplyVault,
+    totalBorrow: data.totalBorrowVault,
+    canBeSupplied: true,
+    canBeBorrowed: false,
+    supplyRate: new Dec(data.supplyRateVault).div(100).toString(),
+    borrowRate: '0',
+  };
+
+  const debtAssetData: FluidAssetData = {
+    symbol: debtAsset.symbol,
+    address: debtAsset.address,
+    price: getEthAmountForDecimals(data.priceOfBorrowToken0InUSD, 8),
+    totalSupply: data.totalSupplyVault,
+    totalBorrow: data.totalBorrowVault,
+    canBeSupplied: false,
+    canBeBorrowed: true,
+    supplyRate: '0',
+    borrowRate: new Dec(data.borrowRateVault).div(100).toString(),
+  };
+
+  const assetsData = {
+    [collAsset.symbol]: collAssetData,
+    [debtAsset.symbol]: debtAssetData,
+  };
+
+  const marketData = {
+    vaultId: +data.vaultId,
+    isSmartColl: data.isSmartColl,
+    isSmartDebt: data.isSmartDebt,
+    marketAddress: data.vault,
+    vaultType: parseVaultType(+data.vaultType),
+    oracle: data.oracle,
+    liquidationPenaltyPercent: new Dec(data.liquidationPenalty).div(100).toString(),
+    collFactor: new Dec(data.collateralFactor).div(10000).toString(), // we want actual factor, not in %, so we divide by 10000 instead of 100
+    liquidationRatio: new Dec(data.liquidationThreshold).div(100).toString(),
+    collAsset0: collAsset.symbol,
+    debtAsset0: debtAsset.symbol,
+    totalPositions: data.totalPositions,
+    totalSupplyVault: getEthAmountForDecimals(data.totalSupplyVault, collAsset.decimals),
+    totalBorrowVault: getEthAmountForDecimals(data.totalBorrowVault, debtAsset.decimals),
+    withdrawalLimit: getEthAmountForDecimals(data.withdrawalLimit, collAsset.decimals),
+    withdrawableUntilLimit: getEthAmountForDecimals(data.withdrawableUntilLimit, collAsset.decimals),
+    withdrawable: getEthAmountForDecimals(data.withdrawable, collAsset.decimals),
+    borrowLimit: getEthAmountForDecimals(data.borrowLimit, debtAsset.decimals),
+    borrowableUntilLimit: getEthAmountForDecimals(data.borrowableUntilLimit, debtAsset.decimals),
+    borrowable: getEthAmountForDecimals(data.borrowable, debtAsset.decimals),
+    borrowLimitUtilization: getEthAmountForDecimals(data.borrowLimitUtilization, debtAsset.decimals),
+    maxBorrowLimit: getEthAmountForDecimals(data.maxBorrowLimit, debtAsset.decimals),
+    baseBorrowLimit: getEthAmountForDecimals(data.baseBorrowLimit, debtAsset.decimals),
+    minimumBorrowing: getEthAmountForDecimals(data.minimumBorrowing, debtAsset.decimals),
+  };
+
+  return {
+    assetsData,
+    marketData,
+  } as FluidMarketData;
+};
+
+export const EMPTY_FLUID_DATA = {
+  usedAssets: {},
+  suppliedUsd: '0',
+  borrowedUsd: '0',
+  borrowLimitUsd: '0',
+  leftToBorrowUsd: '0',
+  ratio: '0',
+  minRatio: '0',
+  netApy: '0',
+  incentiveUsd: '0',
+  totalInterestUsd: '0',
+  isSubscribedToAutomation: false,
+  automationResubscribeRequired: false,
+  lastUpdated: Date.now(),
+};
+
+const parseUserData = (userPositionData: FluidView.UserPositionStructOutputStruct, vaultData: FluidMarketData): FluidVaultData => {
+  const {
+    assetsData,
+    marketData,
+  } = vaultData;
+
+  const payload = {
+    owner: userPositionData.owner,
+    vaultId: marketData.vaultId,
+    ...EMPTY_FLUID_DATA,
+    lastUpdated: Date.now(),
+  };
+  const collAsset = getAssetInfo(marketData.collAsset0);
+  const debtAsset = getAssetInfo(marketData.debtAsset0);
+
+  const supplied = getEthAmountForDecimals(userPositionData.supply, collAsset.decimals);
+  const borrowed = getEthAmountForDecimals(userPositionData.borrow, debtAsset.decimals);
+
+  const collUsedAsset: FluidUsedAsset = {
+    ...EMPTY_USED_ASSET,
+    symbol: collAsset.symbol,
+    collateral: true,
+    supplied,
+    suppliedUsd: new Dec(supplied).mul(assetsData[collAsset.symbol].price).toString(),
+    isSupplied: new Dec(supplied).gt(0),
+  };
+
+  const debtUsedAsset: FluidUsedAsset = {
+    ...EMPTY_USED_ASSET,
+    symbol: debtAsset.symbol,
+    collateral: false,
+    borrowed,
+    borrowedUsd: new Dec(borrowed).mul(assetsData[debtAsset.symbol].price).toString(),
+    isBorrowed: new Dec(borrowed).gt(0),
+  };
+
+  const usedAssets: FluidUsedAssets = {
+    [collAsset.symbol]: collUsedAsset,
+    [debtAsset.symbol]: debtUsedAsset,
+  };
+
+  return {
+    ...payload,
+    usedAssets,
+    ...(getFluidAggregatedData({
+      usedAssets,
+      assetsData,
+      marketData,
+    }) as FluidAggregatedVaultData),
+  };
+};
+
+export const getFluidMarketData = async (web3: Web3, network: NetworkNumber, market: FluidMarketInfo) => {
+  const view = FluidViewContract(web3, network);
+
+  const data = await view.methods.getVaultData(market.marketAddress).call();
+
+  return parseMarketData(data);
+};
+
+export const getFluidVaultIdsForUser = async (web3: Web3,
+  network:NetworkNumber,
+  user: EthAddress): Promise<string[]> => {
+  const view = FluidViewContract(web3, network);
+
+  return view.methods.getUserNftIds(user).call();
+};
+
+
+export const getFluidPosition = async (
+  web3: Web3,
+  network: NetworkNumber,
+  vaultId: string,
+  extractedState: {
+    assetsData: FluidAssetsData
+    marketData: InnerFluidMarketData,
+  },
+): Promise<FluidVaultData> => {
+  const view = FluidViewContract(web3, network);
+
+  const data = await view.methods.getPositionByNftId(vaultId).call();
+
+  const userPositionData = data[0];
+
+  return parseUserData(userPositionData, extractedState);
+};
+
+export const getFluidPositionWithMarket = async (web3: Web3, network: NetworkNumber, vaultId: string) => {
+  const view = FluidViewContract(web3, network);
+  const data = await view.methods.getPositionByNftId(vaultId).call();
+  const marketData = parseMarketData(data.vault);
+  const userData = parseUserData(data.position, marketData);
+
+  return {
+    userData,
+    marketData,
+  };
+};

package/src/helpers/fluidHelpers/index.ts

@@ -0,0 +1,54 @@
+import Dec from 'decimal.js';
+import {
+  FluidAggregatedVaultData,
+  FluidAssetsData,
+  FluidUsedAssets,
+  InnerFluidMarketData,
+} from '../../types';
+import { calcLeverageLiqPrice, getAssetsTotal, isLeveragedPos } from '../../moneymarket';
+import { calculateNetApy } from '../../staking';
+import { MMAssetsData } from '../../types/common';
+
+export const getFluidAggregatedData = ({
+  usedAssets,
+  assetsData,
+  marketData,
+}: {
+  usedAssets: FluidUsedAssets,
+  marketData: InnerFluidMarketData,
+  assetsData: FluidAssetsData
+}): FluidAggregatedVaultData => {
+  const payload = {} as FluidAggregatedVaultData;
+  payload.suppliedUsd = getAssetsTotal(usedAssets, ({ isSupplied }: { isSupplied: boolean }) => isSupplied, ({ suppliedUsd }: { suppliedUsd: string }) => suppliedUsd);
+  payload.borrowedUsd = getAssetsTotal(usedAssets, ({ isBorrowed }: { isBorrowed: boolean }) => isBorrowed, ({ borrowedUsd }: { borrowedUsd: string }) => borrowedUsd);
+
+  const { netApy, incentiveUsd, totalInterestUsd } = calculateNetApy({ usedAssets, assetsData: assetsData as unknown as MMAssetsData });
+  payload.netApy = netApy;
+  payload.incentiveUsd = incentiveUsd;
+  payload.totalInterestUsd = totalInterestUsd;
+  const collFactor = marketData.collFactor;
+  const liqRatio = marketData.liquidationRatio;
+
+  payload.borrowLimitUsd = new Dec(payload.suppliedUsd).mul(collFactor).toString();
+  payload.liquidationLimitUsd = new Dec(payload.suppliedUsd).mul(liqRatio).div(100).toString();
+  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.suppliedUsd).div(payload.borrowedUsd).mul(100).toString() : '0';
+
+  const { leveragedType, leveragedAsset } = isLeveragedPos(usedAssets);
+
+  payload.leveragedType = leveragedType;
+  if (leveragedType !== '') {
+    payload.leveragedAsset = leveragedAsset;
+    let assetPrice = 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/index.ts

@@ -6,4 +6,6 @@ export * as makerHelpers from './makerHelpers';
 export * as chickenBondsHelpers from './chickenBondsHelpers';
 export * as morphoBlueHelpers from './morphoBlueHelpers';
 export * as llamaLendHelpers from './llamaLendHelpers';
-export * as eulerV2Helpers from './eulerHelpers';
+export * as liquityV2Helpers from './liquityV2Helpers';
+export * as eulerV2Helpers from './eulerHelpers';
+export * as fluidHelpers from './fluidHelpers';

package/src/helpers/liquityV2Helpers/index.ts

@@ -0,0 +1,80 @@
+import Dec from 'decimal.js';
+import { calcLeverageLiqPrice, getAssetsTotal, isLeveragedPos } from '../../moneymarket';
+import {
+  LiquityV2AggregatedTroveData, LiquityV2AssetsData, LiquityV2UsedAsset, LiquityV2UsedAssets,
+} from '../../types';
+import { calculateInterestEarned } from '../../staking';
+
+export const calculateNetApyLiquityV2 = (usedAssets: LiquityV2UsedAssets, assetsData: LiquityV2AssetsData, interestRate: string) => {
+  const sumValues = Object.values(usedAssets).reduce((_acc, usedAsset) => {
+    const acc = { ..._acc };
+    const assetData = assetsData[usedAsset.symbol];
+
+    if (usedAsset.suppliedUsd) {
+      const amount = usedAsset.suppliedUsd;
+      acc.suppliedUsd = new Dec(acc.suppliedUsd).add(amount).toString();
+      if (assetData.incentiveSupplyApy) {
+        const incentiveInterest = calculateInterestEarned(amount, assetData.incentiveSupplyApy, 'year', true);
+        acc.incentiveUsd = new Dec(acc.incentiveUsd).add(incentiveInterest).toString();
+      }
+    }
+
+    if (usedAsset.borrowedUsd) {
+      const amount = usedAsset.borrowedUsd;
+      acc.borrowedUsd = new Dec(acc.borrowedUsd).add(amount).toString();
+      const rate = interestRate;
+      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 getLiquityV2AggregatedPositionData = ({
+  usedAssets,
+  assetsData,
+  minCollRatio,
+  interestRate,
+}: {
+  usedAssets: LiquityV2UsedAssets
+  assetsData: LiquityV2AssetsData
+  minCollRatio: string
+  interestRate: string
+}): LiquityV2AggregatedTroveData => {
+  const payload = {} as LiquityV2AggregatedTroveData;
+  payload.suppliedUsd = getAssetsTotal(usedAssets, (usedAsset: LiquityV2UsedAsset) => usedAsset, ({ suppliedUsd }: { suppliedUsd: string }) => suppliedUsd);
+  payload.borrowedUsd = getAssetsTotal(usedAssets, (usedAsset: LiquityV2UsedAsset) => usedAsset, ({ borrowedUsd }: { borrowedUsd: string }) => borrowedUsd);
+  payload.borrowLimitUsd = new Dec(payload.suppliedUsd).div(minCollRatio).mul(100).toString();
+  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.suppliedUsd).div(payload.borrowedUsd).mul(100).toString() : '0';
+  const { netApy, incentiveUsd, totalInterestUsd } = calculateNetApyLiquityV2(usedAssets, assetsData, interestRate);
+  payload.netApy = netApy;
+  payload.incentiveUsd = incentiveUsd;
+  payload.totalInterestUsd = totalInterestUsd;
+
+  const { leveragedType, leveragedAsset } = isLeveragedPos(usedAssets);
+  payload.leveragedType = leveragedType;
+  payload.leveragedAsset = leveragedAsset;
+  payload.liquidationPrice = '';
+  if (leveragedType !== '') {
+    const assetPrice = assetsData[leveragedAsset].price;
+    payload.liquidationPrice = calcLeverageLiqPrice(leveragedType, assetPrice, payload.borrowedUsd, payload.borrowLimitUsd);
+  }
+
+  return payload;
+};

package/src/index.ts

@@ -1,5 +1,6 @@
 import './setup';
 
+import * as fluid from './fluid';
 import * as aaveV3 from './aaveV3';
 import * as morphoAaveV3 from './morphoAaveV3';
 import * as aaveV2 from './aaveV2';
@@ -9,6 +10,7 @@ import * as compoundV2 from './compoundV2';
 import * as spark from './spark';
 import * as curveUsd from './curveUsd';
 import * as liquity from './liquity';
+import * as liquityV2 from './liquityV2';
 import * as maker from './maker';
 import * as staking from './staking';
 import * as multicall from './multicall';
@@ -34,6 +36,7 @@ export {
   spark,
   curveUsd,
   liquity,
+  liquityV2,
   maker,
   chickenBonds,
   exchange,
@@ -45,4 +48,5 @@ export {
   morphoBlue,
   llamaLend,
   eulerV2,
+  fluid,
 };

package/src/liquityV2/index.ts

@@ -0,0 +1,228 @@
+import Web3 from 'web3';
+import Dec from 'decimal.js';
+import { assetAmountInEth, getAssetInfo } from '@defisaver/tokens';
+import { createContractWrapper, LiquityV2ViewContract } from '../contracts';
+import { EthAddress, NetworkNumber } from '../types/common';
+import {
+  InnerLiquityV2MarketData,
+  LIQUITY_V2_TROVE_STATUS_ENUM,
+  LiquityV2AssetsData, LiquityV2MarketData, LiquityV2MarketInfo, LiquityV2TroveData, LiquityV2UsedAssets,
+} from '../types';
+import { getStakingApy, STAKING_ASSETS } from '../staking';
+import { getLiquityV2AggregatedPositionData } from '../helpers/liquityV2Helpers';
+import { addToObjectIf, compareAddresses, ethToWeth } from '../services/utils';
+import { LiquityV2View } from '../types/contracts/generated';
+import { ZERO_ADDRESS } from '../constants';
+
+
+export const getLiquityV2MarketData = async (web3: Web3, network: NetworkNumber, selectedMarket: LiquityV2MarketInfo, mainnetWeb3: Web3): Promise<LiquityV2MarketData> => {
+  const viewContract = LiquityV2ViewContract(web3, network);
+  const { marketAddress, debtToken, collateralToken } = selectedMarket;
+  const data = await viewContract.methods.getMarketData(marketAddress).call();
+  const hintHelperAddress = data.hintHelpers;
+  const troveNFTAddress = data.troveNFT;
+  const borrowerOperationsAddress = data.borrowerOperations;
+  const troveManagerAddress = data.troveManager;
+  const stabilityPoolAddress = data.stabilityPool;
+  const collSurplusPoolAddress = data.collSurplusPool;
+  const activePoolAddress = data.activePool;
+
+  const minCollRatio = new Dec(data.MCR).div(1e16).toString();
+  const criticalCollRatio = new Dec(data.CCR).div(1e18).toString();
+
+  const totalMarketBorrow = assetAmountInEth(data.entireSystemDebt);
+  const totalMarketSupply = assetAmountInEth(data.entireSystemColl);
+  const collPrice = assetAmountInEth(data.collPrice);
+
+  const totalCollRatio = new Dec(totalMarketSupply).mul(collPrice).div(totalMarketBorrow).toString();
+  const leftToBorrowGlobal = new Dec(totalMarketSupply).mul(collPrice).div(criticalCollRatio).sub(totalMarketBorrow)
+    .toString();
+  const minCollAmountForCurrentBorrow = new Dec(totalMarketBorrow).mul(criticalCollRatio).div(collPrice).toString();
+  const leftToWithdrawGlobal = new Dec(totalMarketSupply).sub(minCollAmountForCurrentBorrow).toString();
+
+  const assetsData: LiquityV2AssetsData = {};
+  assetsData[debtToken] = {
+    symbol: debtToken,
+    address: getAssetInfo(debtToken, network).address,
+    price: '1',
+    totalSupply: '0',
+    totalBorrow: totalMarketBorrow,
+    canBeSupplied: false,
+    canBeBorrowed: true,
+    leftToBorrowGlobal,
+    leftToWithdrawGlobal: '0',
+  };
+  assetsData[collateralToken] = {
+    symbol: collateralToken,
+    address: getAssetInfo(ethToWeth(collateralToken), network).address,
+    price: collPrice,
+    totalSupply: totalMarketSupply,
+    totalBorrow: '0',
+    canBeSupplied: true,
+    canBeBorrowed: false,
+    leftToBorrowGlobal: '0',
+    leftToWithdrawGlobal,
+  };
+  if (STAKING_ASSETS.includes(collateralToken)) {
+    assetsData[collateralToken].incentiveSupplyApy = await getStakingApy(collateralToken, mainnetWeb3);
+    assetsData[collateralToken].incentiveSupplyToken = collateralToken;
+  }
+
+  return {
+    assetsData,
+    marketData: {
+      minCollRatio,
+      totalCollRatio: new Dec(totalCollRatio).mul(100).toString(),
+      criticalCollRatio: new Dec(criticalCollRatio).mul(100).toString(),
+      isUnderCollateralized: new Dec(totalCollRatio).lt(criticalCollRatio),
+      hintHelperAddress,
+      troveNFTAddress,
+      borrowerOperationsAddress,
+      troveManagerAddress,
+      stabilityPoolAddress,
+      collSurplusPoolAddress,
+      activePoolAddress,
+    },
+  };
+};
+
+const _getUserTroves = async (viewContract: any, account: EthAddress, marketAddress: EthAddress, startIndex = 0, endIndex = 100) => viewContract.methods.getUserTroves(account, marketAddress, startIndex, endIndex).call();
+
+const getUserTroves = async (viewContract: any, account: EthAddress, marketAddress: EthAddress, startIndex = 0, endIndex = 100, troves: LiquityV2View.ExistingTroveStructOutput[] = []): Promise<{ troves: LiquityV2View.ExistingTroveStructOutput[], nextFreeTroveIndex: string }> => {
+  const result = await _getUserTroves(viewContract, account, marketAddress, startIndex, endIndex);
+  const newStartIndex = endIndex + 1;
+  const nextFreeTroveIndex = result.nextFreeTroveIndex;
+  const existingTroves = [...troves, ...result.troves];
+  if (nextFreeTroveIndex !== '-1') return { troves: existingTroves.filter((trove) => trove.ownedByUser), nextFreeTroveIndex };
+  return getUserTroves(viewContract, account, marketAddress, newStartIndex, newStartIndex + 100, existingTroves);
+};
+
+const TransferEventSig = '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef';
+
+const nftContractCreationBlockMapping = {
+  ETH: 21686215,
+  wstETH: 21686238,
+  rETH: 21686257,
+};
+
+const getTransferredTroves = async (web3: Web3, network: NetworkNumber, troveNFTAddress: EthAddress, limitBlocksForEventFetching: boolean, collAsset: string, account: EthAddress): Promise<{ troveId: string }[]> => {
+  const nftContract = createContractWrapper(web3, network, 'LiquityV2TroveNFT', troveNFTAddress);
+  // @ts-ignore
+  const nftContractCreationBlock = nftContractCreationBlockMapping[collAsset];
+  const currentBlock = await web3.eth.getBlockNumber();
+  const events = await nftContract.getPastEvents(
+    TransferEventSig,
+    {
+      filter: { to: account },
+      fromBlock: limitBlocksForEventFetching ? (currentBlock - 1000) : nftContractCreationBlock,
+    },
+  );
+  const userTransferredTroves = events.filter((event) => !compareAddresses(event.returnValues.from, ZERO_ADDRESS) && compareAddresses(event.returnValues.to, account));
+
+  // check if the last know transfer address is the user
+  userTransferredTroves.forEach((event, index) => {
+    const otherTransfers = events.filter((e) => event.blockNumber < e.blockNumber && e.returnValues.tokenId === event.returnValues.tokenId);
+    // @ts-ignore
+    userTransferredTroves[index].invalid = !!otherTransfers.length;
+  });
+  // @ts-ignore
+  return userTransferredTroves.filter((event) => !event.invalid).map((event) => ({ troveId: event.returnValues.tokenId }));
+};
+
+export const getLiquityV2UserTroveIds = async (web3: Web3, network: NetworkNumber, selectedMarket: LiquityV2MarketInfo, troveNFTAddress: EthAddress, limitBlocksForEventFetching: boolean, account: EthAddress): Promise<{ troves: { troveId: string }[], nextFreeTroveIndex: string }> => {
+  const viewContract = LiquityV2ViewContract(web3, network);
+  const [{ troves: userTroves, nextFreeTroveIndex }, userTransferredTroves] = await Promise.all([
+    getUserTroves(viewContract, account, selectedMarket.marketAddress),
+    getTransferredTroves(web3, network, troveNFTAddress, limitBlocksForEventFetching, selectedMarket.collateralToken, account),
+  ]);
+  const troves = [...userTroves.map(({ troveId }) => ({ troveId })), ...userTransferredTroves];
+  const filteredTroves = troves.filter((value, index, self) => index === self.findIndex((t) => (
+    t.troveId === value.troveId
+  )),
+  );
+  return { troves: filteredTroves, nextFreeTroveIndex };
+};
+
+const _getDebtInFront = async (viewContract: any, marketAddress: EthAddress, troveId: string, accumulatedSum = '0', iterations = 2000) => viewContract.methods.getDebtInFront(marketAddress, troveId, accumulatedSum, iterations).call();
+
+export const getDebtInFrontLiquityV2 = async (viewContract: any, marketAddress: EthAddress, troveId: string, accumulatedSum = '0', iterations = 2000): Promise<string> => {
+  const { debt, next } = await _getDebtInFront(viewContract, marketAddress, troveId, accumulatedSum, iterations);
+  if (next === '0') return assetAmountInEth(debt);
+  return getDebtInFrontLiquityV2(viewContract, marketAddress, next, debt, iterations);
+};
+
+export const getLiquityV2TroveData = async (
+  web3: Web3,
+  network: NetworkNumber,
+  {
+    selectedMarket,
+    assetsData,
+    marketData,
+    troveId,
+  }:
+  {
+    selectedMarket: LiquityV2MarketInfo,
+    assetsData: LiquityV2AssetsData,
+    marketData: InnerLiquityV2MarketData,
+    troveId: string
+  },
+): Promise<LiquityV2TroveData> => {
+  const viewContract = LiquityV2ViewContract(web3, network);
+  const { minCollRatio } = marketData;
+  const { collateralToken, marketAddress, debtToken } = selectedMarket;
+  const [data, debtInFront] = await Promise.all([
+    viewContract.methods.getTroveInfo(marketAddress, troveId).call(),
+    getDebtInFrontLiquityV2(viewContract, marketAddress, troveId),
+  ]);
+  const usedAssets: LiquityV2UsedAssets = {};
+
+  const debtAssetData = assetsData[debtToken];
+  const borrowed = assetAmountInEth(data.debtAmount);
+  usedAssets[debtToken] = {
+    symbol: debtToken,
+    supplied: '0',
+    suppliedUsd: '0',
+    borrowed,
+    borrowedUsd: new Dec(borrowed).mul(debtAssetData.price).toString(),
+    isBorrowed: true,
+    isSupplied: false,
+  };
+
+  const collAssetData = assetsData[collateralToken];
+  const suppliedColl = assetAmountInEth(data.collAmount);
+  usedAssets[collateralToken] = {
+    symbol: collateralToken,
+    supplied: suppliedColl,
+    suppliedUsd: new Dec(suppliedColl).mul(collAssetData.price).toString(),
+    borrowed: '0',
+    borrowedUsd: '0',
+    isBorrowed: false,
+    isSupplied: true,
+    collateral: true,
+  };
+
+  const collRatio = new Dec(data.TCRatio).div(1e16).toString();
+  const interestRate = new Dec(data.annualInterestRate).div(1e16).toString();
+  const interestBatchManager = data.interestBatchManager;
+
+  const payload: LiquityV2TroveData = {
+    usedAssets,
+    troveId,
+    interestRate,
+    interestBatchManager,
+    debtInFront,
+    troveStatus: LIQUITY_V2_TROVE_STATUS_ENUM[parseInt(data.status, 10)],
+    ...getLiquityV2AggregatedPositionData({
+      usedAssets, assetsData, minCollRatio, interestRate,
+    }),
+    collRatio,
+  };
+
+  return payload;
+};
+
+export const getLiquityV2ClaimableCollateral = async (collSurplusPoolAddress: EthAddress, account: EthAddress, web3: Web3, network: NetworkNumber): Promise<string> => {
+  const collSurplusPoolContract = createContractWrapper(web3, network, 'LiquityV2CollSurplusPool', collSurplusPoolAddress);
+  const claimableCollateral = await collSurplusPoolContract.methods.getCollateral(account).call();
+  return claimableCollateral;
+};

package/src/markets/aave/marketAssets.ts

@@ -11,7 +11,7 @@ export const morphoAaveV2AssetDefaultMarket = ['DAI', 'ETH', 'USDC', 'USDT', 'WB
 
 export const morphoAaveV3AssetEthMarket = ['ETH', 'wstETH', 'DAI', 'USDC', 'WBTC', 'rETH', 'cbETH', 'sDAI', 'USDT'];
 
-export const aaveV3AssetsDefaultMarketEth = ['ETH', 'wstETH', 'WBTC', 'USDC', 'DAI', 'LINK', 'AAVE', 'cbETH', 'USDT', 'rETH', 'LUSD', 'CRV', 'MKR', 'SNX', 'BAL', 'UNI', 'LDO', 'ENS', '1INCH', 'FRAX', 'GHO', 'RPL', 'sDAI', 'STG', 'KNC', 'FXS', 'crvUSD', 'PYUSD', 'weETH', 'osETH', 'USDe', 'ETHx', 'sUSDe', 'tBTC', 'cbBTC', 'USDS', 'rsETH'];
+export const aaveV3AssetsDefaultMarketEth = ['ETH', 'wstETH', 'WBTC', 'USDC', 'DAI', 'LINK', 'AAVE', 'cbETH', 'USDT', 'rETH', 'LUSD', 'CRV', 'MKR', 'SNX', 'BAL', 'UNI', 'LDO', 'ENS', '1INCH', 'FRAX', 'GHO', 'RPL', 'sDAI', 'STG', 'KNC', 'FXS', 'crvUSD', 'PYUSD', 'weETH', 'osETH', 'USDe', 'ETHx', 'sUSDe', 'tBTC', 'cbBTC', 'USDS', 'rsETH', 'LBTC'];
 export const aaveV3AssetsDefaultMarketOpt = [
   'DAI', 'USDC.e', 'USDT', 'SUSD', 'AAVE', 'LINK', 'WBTC', 'ETH', 'OP', 'wstETH', 'LUSD', 'MAI', 'rETH', 'USDC',
 ];