fix: health factor calculation based on increased amount

Author: satanworker

src/helpers/useTransactionHandler.tsx

@@ -112,7 +112,7 @@ export const useTransactionHandler = ({
   };
 
   const approval = async (approvals?: Approval[]) => {
-    console.log(approvalTxes, 'approvalTxes');
+    console.log(approvalTxes, 'approvalTxes', approvals);
     if (approvalTxes) {
       console.log(approvalTxes, 'approvalTxes');
       if (usePermit && approvals && approvals?.length > 0) {
@@ -182,9 +182,7 @@ export const useTransactionHandler = ({
       } else {
         try {
           setApprovalTxState({ ...approvalTxState, loading: true });
-          console.log('no permit should call approval', approvalTxes);
           const params = await Promise.all(approvalTxes.map((approvalTx) => approvalTx.tx()));
-          console.log(params, 'params');
           const approvalResponses = await Promise.all(
             params.map(
               (param) =>
@@ -234,7 +232,6 @@ export const useTransactionHandler = ({
     if (approvalTxes && usePermit && handleGetPermitTxns) {
       if (!signatures.length || !signatureDeadline) throw new Error('signature needed');
       try {
-        console.log(signatures, 'signatures');
         setMainTxState({ ...mainTxState, loading: true });
         const txns = await handleGetPermitTxns(signatures, signatureDeadline);
         const params = await txns[0].tx();
@@ -260,7 +257,6 @@ export const useTransactionHandler = ({
           action: TxAction.MAIN_ACTION,
         });
       } catch (error) {
-        console.log(error, 'error');
         const parsedError = getErrorTextFromError(error, TxAction.GAS_ESTIMATION, false);
         setTxError(parsedError);
         setMainTxState({
@@ -273,7 +269,7 @@ export const useTransactionHandler = ({
       try {
         setMainTxState({ ...mainTxState, loading: true });
         const params = await actionTx.tx();
-        // delete params.gasPrice;
+        delete params.gasPrice;
         return processTx({
           tx: () => sendTx(params),
           successCallback: (txnResponse: TransactionResponse) => {

src/store/poolSelectors.ts

@@ -29,8 +29,8 @@ export const selectCurrentChainIdV2MarketData = (state: RootStore) => {
 };
 
 export const selectCurrentChainIdV3MarketData = (state: RootStore) => {
-  const v2MarketKey = selectCurrentChainIdV3MarketKey(state);
-  const marketData = marketsData[v2MarketKey];
+  const v3MarketKey = selectCurrentChainIdV3MarketKey(state);
+  const marketData = marketsData[v3MarketKey];
   return state.data
     .get(state.currentChainId)
     ?.get(marketData.addresses.LENDING_POOL_ADDRESS_PROVIDER);

src/store/v3MigrationSelectors.ts

@@ -3,6 +3,7 @@ import {
   PoolBaseCurrencyHumanized,
   ReserveDataHumanized,
   UserReserveDataHumanized,
+  valueToWei,
 } from '@aave/contract-helpers';
 import { V3MigrationHelperSignedPermit } from '@aave/contract-helpers/dist/esm/v3-migration-contract/v3MigrationTypes';
 import { formatReserves, formatUserSummary, valueToBigNumber } from '@aave/math-utils';
@@ -69,6 +70,16 @@ const addPercent = (amount: string) => {
   return convertedAmount.plus(convertedAmount.div(1000)).toString();
 };
 
+// adding 1 hour of variable or either stable or variable debt APY similar to swap
+// https://github.com/aave/interface/blob/main/src/hooks/useSwap.ts#L72-L78
+const add1HourBorrowAPY = (amount: string, borrowAPY: string) => {
+  const convertedAmount = valueToBigNumber(amount);
+  const convertedBorrowAPY = valueToBigNumber(borrowAPY);
+  return convertedAmount
+    .plus(convertedAmount.multipliedBy(convertedBorrowAPY).dividedBy(360 * 24))
+    .toString();
+};
+
 export const selectUserBorrowReservesForMigration = (store: RootStore, timestamp: number) => {
   const user = selectUserSummaryAndIncentives(store, timestamp);
   const selectedUserReserves = user.userReservesData
@@ -82,11 +93,31 @@ export const selectUserBorrowReservesForMigration = (store: RootStore, timestamp
     .map(({ reserve, ...userReserve }) => {
       const stableBorrows = valueToBigNumber(userReserve.stableBorrows);
       if (stableBorrows.isGreaterThan(0)) {
-        const increasedAmount = addPercent(userReserve.stableBorrows);
-        return { ...userReserve, reserve, increasedAmount, interestRate: InterestRate.Stable };
+        const increasedAmount = add1HourBorrowAPY(
+          userReserve.stableBorrows,
+          reserve.stableBorrowAPY
+        );
+        const increasedAmountInWei = valueToWei(increasedAmount, reserve.decimals);
+        return {
+          ...userReserve,
+          reserve,
+          increasedAmount,
+          increasedAmountInWei,
+          interestRate: InterestRate.Stable,
+        };
       }
-      const increasedAmount = addPercent(userReserve.variableBorrows);
-      return { ...userReserve, reserve, increasedAmount, interestRate: InterestRate.Variable };
+      const increasedAmount = add1HourBorrowAPY(
+        userReserve.variableBorrows,
+        reserve.variableBorrowAPY
+      );
+      const increasedAmountInWei = valueToWei(increasedAmount, reserve.decimals);
+      return {
+        ...userReserve,
+        reserve,
+        increasedAmount,
+        increasedAmountInWei,
+        interestRate: InterestRate.Variable,
+      };
     });
 
   return selectedUserReserves;
@@ -122,14 +153,26 @@ export const selectV2UserSummaryAfterMigration = (store: RootStore, currentTimes
   const poolReserve = selectCurrentChainIdV2MarketData(store);
 
   const userReserves =
-    poolReserve?.userReserves?.filter((userReserve) => {
-      if (
-        store.selectedMigrationSupplyAssets[userReserve.underlyingAsset] ||
-        store.selectedMigrationBorrowAssets[userReserve.underlyingAsset]
-      ) {
-        return false;
+    poolReserve?.userReserves?.map((userReserve) => {
+      let scaledATokenBalance = userReserve.scaledATokenBalance;
+      let principalStableDebt = userReserve.principalStableDebt;
+      let scaledVariableDebt = userReserve.scaledVariableDebt;
+
+      const isSupplyAsset = store.selectedMigrationSupplyAssets[userReserve.underlyingAsset];
+      if (isSupplyAsset) {
+        scaledATokenBalance = '0';
+      }
+      const isBorrowAsset = store.selectedMigrationBorrowAssets[userReserve.underlyingAsset];
+      if (isBorrowAsset) {
+        principalStableDebt = '0';
+        scaledVariableDebt = '0';
       }
-      return true;
+      return {
+        ...userReserve,
+        principalStableDebt,
+        scaledATokenBalance,
+        scaledVariableDebt,
+      };
     }) || [];
 
   const baseCurrencyData = selectFormatBaseCurrencyData(poolReserve);
@@ -153,34 +196,45 @@ export const selectV3UserSummaryAfterMigration = (store: RootStore, currentTimes
   const borrows = selectUserBorrowReservesForMigration(store, currentTimestamp);
 
   //TODO: refactor that to be more efficient
-  const suppliesMap = supplies.concat(borrows).reduce((obj, item) => {
+  const suppliesMap = supplies.concat(supplies).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
-        );
-        return {
-          ...userReserve,
-          scaledATokenBalance: combinedScaledATokenBalance,
-          scaledVariableDebt: combine(
-            userReserve.scaledVariableDebt,
-            suppliedAsset.scaledVariableDebt
-          ),
-          principalStableDebt: combine(
-            userReserve.principalStableDebt,
-            suppliedAsset.principalStableDebt
-          ),
-        };
-      }
-      return userReserve;
-    }) || [];
+  const borrowsMap = borrows.concat(borrows).reduce((obj, item) => {
+    obj[item.underlyingAsset] = item;
+    return obj;
+  }, {} as Record<string, typeof borrows[0]>);
+
+  const userReserves = poolReserveV3?.userReserves?.map((userReserve) => {
+    let scaledATokenBalance = userReserve.scaledATokenBalance;
+    let scaledVariableDebt = userReserve.scaledVariableDebt;
+    let principalStableDebt = userReserve.principalStableDebt;
+    const reserve = poolReserveV3.reserves?.filter(
+      (reserve) => reserve.underlyingAsset == userReserve.underlyingAsset
+    );
+    const suppliedAsset = suppliesMap[userReserve.underlyingAsset];
+    if (suppliedAsset) {
+      scaledATokenBalance = combine(scaledATokenBalance, suppliedAsset.scaledATokenBalance);
+    }
+    const borrowedAsset = borrowsMap[userReserve.underlyingAsset];
+    if (borrowedAsset) {
+      scaledVariableDebt = combine(scaledVariableDebt, borrowedAsset.increasedAmountInWei);
+      principalStableDebt = combine(principalStableDebt, borrowedAsset.increasedAmountInWei);
+    }
+    let usageAsCollateralEnabledOnUser = false;
+    if (reserve && reserve[0]) {
+      usageAsCollateralEnabledOnUser = reserve[0].usageAsCollateralEnabled;
+    }
+
+    return {
+      ...userReserve,
+      scaledATokenBalance,
+      usageAsCollateralEnabledOnUser,
+      scaledVariableDebt,
+      principalStableDebt,
+    };
+  });
 
   const baseCurrencyData = selectFormatBaseCurrencyData(poolReserveV3);