feat: health factor calculations added before and after migration

satanworker · satanworker · commit 201ef6bf4127 · 2022-12-06T18:59:17.000+07:00
diff --git a/pages/v3-migration.page.tsx b/pages/v3-migration.page.tsx
@@ -5,6 +5,7 @@ import { ConnectWalletPaper } from 'src/components/ConnectWalletPaper';
 import { ContentContainer } from 'src/components/ContentContainer';
 import { MigrateV3Modal } from 'src/components/transactions/MigrateV3/MigrateV3Modal';
 import { useAppDataContext } from 'src/hooks/app-data-provider/useAppDataProvider';
+import { useCurrentTimestamp } from 'src/hooks/useCurrentTimestamp';
 import { usePermissions } from 'src/hooks/usePermissions';
 import { useUserReserves } from 'src/hooks/useUserReserves';
 import { MainLayout } from 'src/layouts/MainLayout';
@@ -16,13 +17,32 @@ import { MigrationListItemLoader } from 'src/modules/migration/MigrationListItem
 import { MigrationLists } from 'src/modules/migration/MigrationLists';
 import { MigrationTopPanel } from 'src/modules/migration/MigrationTopPanel';
 import { usePoolDataV3Subscription, useRootStore } from 'src/store/root';
+import {
+  selectV2UserSummaryAfterMigration,
+  selectV3UserSummary,
+  selectV3UserSummaryAfterMigration,
+} from 'src/store/v3MigrationSelectors';
 
 export default function V3Migration() {
   const { loading } = useAppDataContext();
   const { currentAccount, loading: web3Loading } = useWeb3Context();
   const { isPermissionsLoading } = usePermissions();
   const setCurrentMarketForMigration = useRootStore((state) => state.setCurrentMarketForMigration);
 
+  const currentTimeStamp = useCurrentTimestamp(5);
+
+  const v2UserSummaryAfterMigration = useRootStore((state) =>
+    selectV2UserSummaryAfterMigration(state, currentTimeStamp)
+  );
+
+  const v3UserSummaryAfterMigration = useRootStore((state) =>
+    selectV3UserSummaryAfterMigration(state, currentTimeStamp)
+  );
+
+  const v3UserSummaryBeforeMigration = useRootStore((state) =>
+    selectV3UserSummary(state, currentTimeStamp)
+  );
+
   const { user, borrowPositions } = useUserReserves();
 
   const {
@@ -43,7 +63,6 @@ export default function V3Migration() {
   return (
     <>
       <MigrationTopPanel />
-
       {currentAccount && !isPermissionsLoading ? (
         <ContentContainer>
           <MigrationLists
@@ -121,10 +140,10 @@ export default function V3Migration() {
           <Divider sx={{ my: 10 }} />
 
           <MigrationBottomPanel
-            hfV2Current={'1.2'} // TODO: need value
-            hfV2AfterChange={'2'} // TODO: need value
-            hfV3Current={'1.2'} // TODO: need value
-            hfV3AfterChange={'2'} // TODO: need value
+            hfV2Current={user.healthFactor} // TODO: need value
+            hfV2AfterChange={v2UserSummaryAfterMigration.healthFactor} // TODO: need value
+            hfV3Current={v3UserSummaryBeforeMigration.healthFactor} // TODO: need value
+            hfV3AfterChange={v3UserSummaryAfterMigration.healthFactor} // TODO: need value
             disableButton={
               !Object.keys(selectedSupplyAssets).length && !Object.keys(selectedBorrowAssets).length
             }
diff --git a/src/store/poolSelectors.ts b/src/store/poolSelectors.ts
@@ -2,6 +2,7 @@ import { formatReservesAndIncentives, formatUserSummaryAndIncentives } from '@aa
 import { EmodeCategory } from 'src/helpers/types';
 import { fetchIconSymbolAndName, STABLE_ASSETS } from 'src/ui-config/reservePatches';
 import { CustomMarket, MarketDataType, marketsData } from 'src/utils/marketsAndNetworksConfig';
+import { PoolReserve } from './poolSlice';
 
 import { RootStore } from './root';
 
@@ -23,27 +24,47 @@ export const selectCurrentChainIdV2MarketData = (state: RootStore) => {
     ?.get(marketData.addresses.LENDING_POOL_ADDRESS_PROVIDER);
 };
 
+export const selectCurrentChainIdV3MarketData = (state: RootStore) => {
+  const v2MarketKey = selectCurrentChainIdV3MarketKey(state);
+  const marketData = marketsData[v2MarketKey];
+  return state.data
+    .get(state.currentChainId)
+    ?.get(marketData.addresses.LENDING_POOL_ADDRESS_PROVIDER);
+};
+
 export const selectCurrentUserLendingPoolData = (state: RootStore) => {
   return state.data
     .get(state.currentChainId)
     ?.get(state.currentMarketData.addresses.LENDING_POOL_ADDRESS_PROVIDER);
 };
 
+export const selectFormatUserEmodeCategoryId = (reserve?: PoolReserve) => {
+  return reserve?.userEmodeCategoryId || 0;
+};
+
 export const selectCurrentUserEmodeCategoryId = (state: RootStore): number => {
-  return selectCurrentUserLendingPoolData(state)?.userEmodeCategoryId || 0;
+  return selectFormatUserEmodeCategoryId(selectCurrentUserLendingPoolData(state));
+};
+
+export const selectFormatUserReserves = (reserve?: PoolReserve) => {
+  return reserve?.userReserves || [];
 };
 
 export const selectCurrentUserReserves = (state: RootStore) => {
-  return selectCurrentUserLendingPoolData(state)?.userReserves || [];
+  return selectFormatUserReserves(selectCurrentUserLendingPoolData(state));
+};
+
+export const selectFormatReserves = (reserve?: PoolReserve) => {
+  return reserve?.reserves || [];
 };
 
 export const selectCurrentReserves = (state: RootStore) => {
-  return selectCurrentUserLendingPoolData(state)?.reserves || [];
+  return selectFormatReserves(selectCurrentUserLendingPoolData(state));
 };
 
-export const selectCurrentBaseCurrencyData = (state: RootStore) => {
+export const selectFormatBaseCurrencyData = (reserve?: PoolReserve) => {
   return (
-    selectCurrentUserLendingPoolData(state)?.baseCurrencyData || {
+    reserve?.baseCurrencyData || {
       marketReferenceCurrencyDecimals: 0,
       marketReferenceCurrencyPriceInUsd: '0',
       networkBaseTokenPriceInUsd: '0',
@@ -52,6 +73,10 @@ export const selectCurrentBaseCurrencyData = (state: RootStore) => {
   );
 };
 
+export const selectCurrentBaseCurrencyData = (state: RootStore) => {
+  return selectFormatBaseCurrencyData(selectCurrentUserLendingPoolData(state));
+};
+
 export const reserveSortFn = (a: { iconSymbol: string }, b: { iconSymbol: string }) => {
   const aIsStable = STABLE_ASSETS.includes(a.iconSymbol.toUpperCase());
   const bIsStable = STABLE_ASSETS.includes(b.iconSymbol.toUpperCase());
diff --git a/src/store/poolSlice.ts b/src/store/poolSlice.ts
@@ -39,26 +39,20 @@ import { availableMarkets, marketsData, networkConfigs } from 'src/utils/markets
 import { optimizedPath } from 'src/utils/utils';
 import { StateCreator } from 'zustand';
 
-import {
-  selectCurrentChainIdV3MarketKey,
-  selectFormattedReserves,
-} from './poolSelectors';
+import { selectCurrentChainIdV3MarketKey, selectFormattedReserves } from './poolSelectors';
 import { RootStore } from './root';
 
+// TODO: what is the better name for this type?
+export type PoolReserve = {
+  reserves?: ReserveDataHumanized[];
+  baseCurrencyData?: PoolBaseCurrencyHumanized;
+  userEmodeCategoryId?: number;
+  userReserves?: UserReserveDataHumanized[];
+};
+
 // TODO: add chain/provider/account mapping
 export interface PoolSlice {
-  data: Map<
-    number,
-    Map<
-      string,
-      {
-        reserves?: ReserveDataHumanized[];
-        baseCurrencyData?: PoolBaseCurrencyHumanized;
-        userEmodeCategoryId?: number;
-        userReserves?: UserReserveDataHumanized[];
-      }
-    >
-  >;
+  data: Map<number, Map<string, PoolReserve>>;
   refreshPoolData: (marketData?: MarketDataType) => Promise<void>;
   refreshPoolV3Data: () => Promise<void>;
   // methods
@@ -129,7 +123,6 @@ export const createPoolSlice: StateCreator<
       const account = get().account;
       const currentChainId = get().currentChainId;
       const currentMarketData = marketData || get().currentMarketData;
-      console.log(get().currentMarketData, 'currentMarketData');
       const poolDataProviderContract = new UiPoolDataProvider({
         uiPoolDataProviderAddress: currentMarketData.addresses.UI_POOL_DATA_PROVIDER,
         provider: get().jsonRpcProvider(),
diff --git a/src/store/v3MigrationSelectors.ts b/src/store/v3MigrationSelectors.ts
@@ -1,9 +1,19 @@
-import { InterestRate } from '@aave/contract-helpers';
+import {
+  InterestRate,
+  PoolBaseCurrencyHumanized,
+  ReserveDataHumanized,
+  UserReserveDataHumanized,
+} from '@aave/contract-helpers';
 import { V3MigrationHelperSignedPermit } from '@aave/contract-helpers/dist/esm/v3-migration-contract/v3MigrationTypes';
-import { valueToBigNumber } from '@aave/math-utils';
+import { formatReserves, formatUserSummary, valueToBigNumber } from '@aave/math-utils';
 import { SignatureLike } from '@ethersproject/bytes';
-import { BigNumber, BigNumberish, constants } from 'ethers';
+import { BigNumberish, constants } from 'ethers';
+
 import {
+  selectCurrentChainIdV2MarketData,
+  selectCurrentChainIdV3MarketData,
+  selectFormatBaseCurrencyData,
+  selectFormatUserEmodeCategoryId,
   selectUserNonEmtpySummaryAndIncentive,
   selectUserSummaryAndIncentives,
 } from './poolSelectors';
@@ -21,7 +31,6 @@ export const selectUserSupplyIncreasedReservesForMigrationPermits = (
   store: RootStore,
   timestamp: number
 ) => {
-  console.log('selectUserSupplyIncreasedReservesForMigrationPermits')
   return selectedUserSupplyReservesForMigration(store, timestamp).map((userReserve) => {
     const increasedAmount = addPercent(userReserve.underlyingBalance);
     return { ...userReserve, increasedAmount };
@@ -84,7 +93,122 @@ export const selectUserBorrowReservesForMigration = (store: RootStore, timestamp
   return selectedUserReserves;
 };
 
-export const selectCurrentMarketV2Reserves = (store: RootStore, timestamp: number) => {
-  const currentChainId = store.currentChainId;
-  return store.data.get(currentChainId);
+export const selectFormatUserSummaryForMigration = (
+  reserves: ReserveDataHumanized[] = [],
+  userReserves: UserReserveDataHumanized[] = [],
+  baseCurrencyData: PoolBaseCurrencyHumanized,
+  userEmodeCategoryId: number,
+  currentTimestamp: number
+) => {
+  const { marketReferenceCurrencyDecimals, marketReferenceCurrencyPriceInUsd } = baseCurrencyData;
+  const formattedReserves = formatReserves({
+    reserves: reserves,
+    currentTimestamp,
+    marketReferenceCurrencyDecimals: marketReferenceCurrencyDecimals,
+    marketReferencePriceInUsd: marketReferenceCurrencyPriceInUsd,
+  });
+
+  const formattedSummary = formatUserSummary({
+    currentTimestamp,
+    formattedReserves,
+    marketReferenceCurrencyDecimals: marketReferenceCurrencyDecimals,
+    marketReferencePriceInUsd: marketReferenceCurrencyPriceInUsd,
+    userReserves,
+    userEmodeCategoryId: 0,
+  });
+
+  return formattedSummary;
+};
+
+export const selectV2UserSummaryAfterMigration = (store: RootStore, currentTimestamp: number) => {
+  const poolReserve = selectCurrentChainIdV2MarketData(store);
+
+  const userReserves =
+    poolReserve?.userReserves?.filter((userReserve) => {
+      if (
+        store.selectedMigrationSupplyAssets[userReserve.underlyingAsset] ||
+        store.selectedMigrationBorrowAssets[userReserve.underlyingAsset]
+      ) {
+        return false;
+      }
+      return true;
+    }) || [];
+
+  const baseCurrencyData = selectFormatBaseCurrencyData(poolReserve);
+  const userEmodeCategoryId = selectFormatUserEmodeCategoryId(poolReserve);
+
+  return selectFormatUserSummaryForMigration(
+    poolReserve?.reserves,
+    userReserves,
+    baseCurrencyData,
+    userEmodeCategoryId,
+    currentTimestamp
+  );
+};
+
+const combine = (a: string, b: string): string => {
+  return valueToBigNumber(a).plus(valueToBigNumber(b)).toString();
+};
+
+export const selectV3UserSummaryAfterMigration = (store: RootStore, currentTimestamp: number) => {
+  const poolReserveV3 = selectCurrentChainIdV3MarketData(store);
+
+  const supplies = selectedUserSupplyReservesForMigration(store, currentTimestamp);
+  const borrows = selectUserBorrowReservesForMigration(store, currentTimestamp);
+
+  //TODO: refactor that to be more efficient
+  const suppliesMap = supplies.concat(borrows).reduce((obj, item) => {
+    obj[item.underlyingAsset] = item;
+    return obj;
+  }, {} as Record<string, typeof supplies[0]>);
+
+  const userReserves =
+    poolReserveV3?.userReserves?.map((userReserve) => {
+      const suppliedAsset = suppliesMap[userReserve.underlyingAsset];
+      if (suppliedAsset) {
+        const combinedScaledATokenBalance = combine(
+          userReserve.scaledATokenBalance,
+          suppliedAsset.scaledATokenBalance
+        );
+        //TODO: merge only if emode categories are the same?
+        return {
+          ...userReserve,
+          scaledATokenBalance: combinedScaledATokenBalance,
+          scaledVariableDebt: combine(
+            userReserve.scaledVariableDebt,
+            suppliedAsset.scaledVariableDebt
+          ),
+          principalStableDebt: combine(
+            userReserve.principalStableDebt,
+            suppliedAsset.principalStableDebt
+          ),
+        };
+      }
+      return userReserve;
+    }) || [];
+
+  const baseCurrencyData = selectFormatBaseCurrencyData(poolReserveV3);
+  const userEmodeCategoryId = selectFormatUserEmodeCategoryId(poolReserveV3);
+
+  return selectFormatUserSummaryForMigration(
+    poolReserveV3?.reserves,
+    userReserves,
+    baseCurrencyData,
+    userEmodeCategoryId,
+    currentTimestamp
+  );
+};
+
+export const selectV3UserSummary = (store: RootStore, timestamp: number) => {
+  const poolReserveV3 = selectCurrentChainIdV3MarketData(store);
+  const baseCurrencyData = selectFormatBaseCurrencyData(poolReserveV3);
+  const userEmodeCategoryId = selectFormatUserEmodeCategoryId(poolReserveV3);
+
+  return selectFormatUserSummaryForMigration(
+    poolReserveV3?.reserves,
+    poolReserveV3?.userReserves,
+    baseCurrencyData,
+    userEmodeCategoryId,
+    timestamp
+  );
 };
diff --git a/src/store/v3MigrationSlice.ts b/src/store/v3MigrationSlice.ts
@@ -79,7 +79,6 @@ export const createV3MigrationSlice: StateCreator<
 
       const { name } = await getTokenData(underlyingAsset);
       const chainId = get().currentChainId;
-      console.log(name, 'name');
 
       const erc20_2612Service = new ERC20_2612Service(get().jsonRpcProvider());
 
