feat: migrate with borrow and permits continue

satanworker · satanworker · commit 4d71cd644889 · 2022-12-02T19:42:38.000+07:00
diff --git a/src/helpers/useTransactionHandler.tsx b/src/helpers/useTransactionHandler.tsx
@@ -272,11 +272,8 @@ export const useTransactionHandler = ({
     if ((!usePermit || !approvalTxes) && actionTx) {
       try {
         setMainTxState({ ...mainTxState, loading: true });
-        console.log(actionTx, 'actionTx');
         const params = await actionTx.tx();
-        console.log(params, 'actionTx');
         // delete params.gasPrice;
-        console.log(params);
         return processTx({
           tx: () => sendTx(params),
           successCallback: (txnResponse: TransactionResponse) => {
@@ -319,7 +316,6 @@ export const useTransactionHandler = ({
         return handleGetTxns()
           .then(async (data) => {
             if (!mounted.current) return;
-            // setApprovalTxes(data.filte((tx) => tx.txType === 'ERC20_APPROVAL'));
             const approvals = data.filter((tx) => tx.txType == 'ERC20_APPROVAL');
             if (approvals.length > 0) {
               setApprovalTxes(approvals);
diff --git a/src/store/poolSelectors.ts b/src/store/poolSelectors.ts
@@ -10,6 +10,8 @@ export const selectCurrentUserLendingPoolData = (state: RootStore) => {
     ?.get(state.currentMarketData.addresses.LENDING_POOL_ADDRESS_PROVIDER);
 };
 
+export const selectLendingPoolDataV2 = (state: RootStore) => {};
+
 export const selectCurrentUserEmodeCategoryId = (state: RootStore): number => {
   return selectCurrentUserLendingPoolData(state)?.userEmodeCategoryId || 0;
 };
diff --git a/src/store/poolSlice.ts b/src/store/poolSlice.ts
@@ -34,8 +34,8 @@ import { RepayActionProps } from 'src/components/transactions/Repay/RepayActions
 import { SupplyActionProps } from 'src/components/transactions/Supply/SupplyActions';
 import { SwapActionProps } from 'src/components/transactions/Swap/SwapActions';
 import { getRepayCallData, getSwapCallData } from 'src/hooks/useSwap';
-import { MarketDataType, marketsData } from 'src/ui-config/marketsConfig';
-import { availableMarkets, networkConfigs } from 'src/utils/marketsAndNetworksConfig';
+import { MarketDataType } from 'src/ui-config/marketsConfig';
+import { availableMarkets, marketsData, networkConfigs } from 'src/utils/marketsAndNetworksConfig';
 import { optimizedPath } from 'src/utils/utils';
 import { StateCreator } from 'zustand';
 
@@ -199,9 +199,8 @@ export const createPoolSlice: StateCreator<
     },
     refreshPoolV3Data: async () => {
       // how to determine which v2 markets to pool? for now always fetch polygon fork
-      const v3MarketData = marketsData[availableMarkets[11]];
-      console.log(marketsData);
-      // get().refreshPoolData(availableMarkets);
+      const v3MarketData = marketsData['fork_proto_polygon_v3'];
+      get().refreshPoolData(v3MarketData);
     },
     mint: async (args) => {
       if (!get().currentMarketData.addresses.FAUCET)
diff --git a/src/store/protocolDataSlice.ts b/src/store/protocolDataSlice.ts
@@ -38,7 +38,6 @@ export const createProtocolDataSlice: StateCreator<
     setCurrentMarket: (market, omitQueryParameterUpdate) => {
       if (!availableMarkets.includes(market as CustomMarket)) return;
       const nextMarketData = marketsData[market];
-      console.log(marketsData['fork_proto_polygon_v3'], marketsData);
       localStorage.setItem('selectedMarket', market);
       if (!omitQueryParameterUpdate) {
         setQueryParameter('marketName', market);
diff --git a/src/store/root.ts b/src/store/root.ts
@@ -1,5 +1,6 @@
 import { enableMapSet } from 'immer';
 import { CustomMarket } from 'src/ui-config/marketsConfig';
+import { marketsData } from 'src/utils/marketsAndNetworksConfig';
 import create from 'zustand';
 import { devtools } from 'zustand/middleware';
 
diff --git a/src/store/v3MigrationSelectors.ts b/src/store/v3MigrationSelectors.ts
@@ -1,14 +1,89 @@
-import { selectUserNonEmtpySummaryAndIncentive } from './poolSelectors';
+import { InterestRate } from '@aave/contract-helpers';
+import { V3MigrationHelperSignedPermit } from '@aave/contract-helpers/dist/esm/v3-migration-contract/v3MigrationTypes';
+import { valueToBigNumber } from '@aave/math-utils';
+import { SignatureLike } from '@ethersproject/bytes';
+import { BigNumber, BigNumberish, constants } from 'ethers';
+import {
+  selectUserNonEmtpySummaryAndIncentive,
+  selectUserSummaryAndIncentives,
+} from './poolSelectors';
 import { RootStore } from './root';
 
-export const selectedUserReservesForMigration = (store: RootStore, timestamp: number) => {
+export const selectedUserSupplyReservesForMigration = (store: RootStore, timestamp: number) => {
   const user = selectUserNonEmtpySummaryAndIncentive(store, timestamp);
   const selectedUserReserves = user.userReservesData.filter(
     (userReserve) => store.selectedMigrationSupplyAssets[userReserve.underlyingAsset]
   );
   return selectedUserReserves;
 };
 
+export const selectUserSupplyIncreasedReservesForMigrationPermits = (
+  store: RootStore,
+  timestamp: number
+) => {
+  console.log('selectUserSupplyIncreasedReservesForMigrationPermits')
+  return selectedUserSupplyReservesForMigration(store, timestamp).map((userReserve) => {
+    const increasedAmount = addPercent(userReserve.underlyingBalance);
+    return { ...userReserve, increasedAmount };
+  });
+};
+
+export const selectUserSupplyAssetsForMigrationNoPermit = (store: RootStore, timestamp: number) => {
+  const selectedUserReserves = selectedUserSupplyReservesForMigration(store, timestamp);
+  return selectedUserReserves.map(({ underlyingAsset, reserve }) => {
+    const deadline = Math.floor(Date.now() / 1000 + 3600);
+    return {
+      amount: constants.MaxUint256.toString(),
+      aToken: reserve.aTokenAddress,
+      underlyingAsset: underlyingAsset,
+      deadline,
+    };
+  });
+};
+
+export const selectUserSupplyAssetsForMigrationWithPermits = (
+  store: RootStore,
+  signatures: SignatureLike[],
+  deadline: BigNumberish
+): V3MigrationHelperSignedPermit[] => {
+  return store.approvalPermitsForMigrationAssets.map(({ amount, underlyingAsset }, index) => {
+    return {
+      signedPermit: signatures[index],
+      deadline,
+      aToken: underlyingAsset,
+      value: amount,
+    };
+  });
+};
+
+const addPercent = (amount: string) => {
+  const convertedAmount = valueToBigNumber(amount);
+  return convertedAmount.plus(convertedAmount.div(1000)).toString();
+};
+
+export const selectUserBorrowReservesForMigration = (store: RootStore, timestamp: number) => {
+  const user = selectUserSummaryAndIncentives(store, timestamp);
+  const selectedUserReserves = user.userReservesData
+    // should filter for empty positions?
+    .filter(
+      (userReserve) =>
+        valueToBigNumber(userReserve.stableBorrows).isGreaterThan(0) ||
+        valueToBigNumber(userReserve.variableBorrows).isGreaterThan(0)
+    )
+    .filter((userReserve) => store.selectedMigrationBorrowAssets[userReserve.underlyingAsset])
+    .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 = addPercent(userReserve.variableBorrows);
+      return { ...userReserve, reserve, increasedAmount, interestRate: InterestRate.Variable };
+    });
+
+  return selectedUserReserves;
+};
+
 export const selectCurrentMarketV2Reserves = (store: RootStore, timestamp: number) => {
   const currentChainId = store.currentChainId;
   return store.data.get(currentChainId);
diff --git a/src/store/v3MigrationSlice.ts b/src/store/v3MigrationSlice.ts
@@ -4,16 +4,26 @@ import {
   EthereumTransactionTypeExtended,
   V3MigrationHelperService,
   valueToWei,
+  Pool,
+  InterestRate,
 } from '@aave/contract-helpers';
+import { V3MigrationHelperSignedPermit } from '@aave/contract-helpers/dist/esm/v3-migration-contract/v3MigrationTypes';
+import { valueToBigNumber } from '@aave/math-utils';
 import { SignatureLike } from '@ethersproject/bytes';
 import dayjs from 'dayjs';
-import { BigNumberish, constants } from 'ethers';
+import { BigNumber, BigNumberish, constants } from 'ethers';
 import { produce } from 'immer';
 import { Approval } from 'src/helpers/useTransactionHandler';
 import { StateCreator } from 'zustand';
 
 import { RootStore } from './root';
-import { selectedUserReservesForMigration } from './v3MigrationSelectors';
+import {
+  selectedUserSupplyReservesForMigration,
+  selectUserBorrowReservesForMigration,
+  selectUserSupplyAssetsForMigrationNoPermit,
+  selectUserSupplyAssetsForMigrationWithPermits,
+  selectUserSupplyIncreasedReservesForMigrationPermits,
+} from './v3MigrationSelectors';
 
 export type V3MigrationSlice = {
   //STATE
@@ -38,6 +48,9 @@ export type V3MigrationSlice = {
     deadline: BigNumberish
   ) => Promise<EthereumTransactionTypeExtended[]>;
   migrateWithoutPermits: () => Promise<EthereumTransactionTypeExtended[]>;
+  migrateBorrow: (
+    signedPermits?: V3MigrationHelperSignedPermit[]
+  ) => Promise<EthereumTransactionTypeExtended[]>;
   _testMigration: () => void;
   // migrateSelectedPositions: () => void;
 };
@@ -71,7 +84,14 @@ export const createV3MigrationSlice: StateCreator<
 
       const typeData = {
         types: {
+          EIP712Domain: [
+            { name: 'name', type: 'string' },
+            { name: 'version', type: 'string' },
+            { name: 'chainId', type: 'uint256' },
+            { name: 'verifyingContract', type: 'address' },
+          ],
           Permit: [
+            // { name: 'PERMIT_TYPEHASH', type: 'string' },
             { name: 'owner', type: 'address' },
             { name: 'spender', type: 'address' },
             { name: 'value', type: 'uint256' },
@@ -121,12 +141,12 @@ export const createV3MigrationSlice: StateCreator<
     getApprovePermitsForSelectedAssets: async () => {
       const timestamp = dayjs().unix();
       const approvalPermitsForMigrationAssets = await Promise.all(
-        selectedUserReservesForMigration(get(), timestamp).map(
-          async ({ reserve, underlyingBalance }): Promise<Approval> => {
+        selectUserSupplyIncreasedReservesForMigrationPermits(get(), timestamp).map(
+          async ({ reserve, increasedAmount, underlyingBalance }): Promise<Approval> => {
+            console.log(underlyingBalance, 'underlyingBalance');
             const { getTokenData } = new ERC20Service(get().jsonRpcProvider());
-            const { name, decimals } = await getTokenData(reserve.aTokenAddress);
-            const amount = (Number(underlyingBalance) + 100).toString();
-            const convertedAmount = valueToWei(amount, decimals);
+            const { decimals } = await getTokenData(reserve.aTokenAddress);
+            const convertedAmount = valueToWei(increasedAmount, decimals);
             return {
               // TODO: should we allow spending of exact ammount of the reserver?
               amount: convertedAmount,
@@ -140,53 +160,38 @@ export const createV3MigrationSlice: StateCreator<
       return approvalPermitsForMigrationAssets;
     },
     migrateWithoutPermits: () => {
+      console.log('should be called before gas');
       const timestamp = dayjs().unix();
       set({ timestamp });
-      const assets: {
-        aToken: string;
-        deadline: number;
-        amount: string;
-        underlyingAsset: string;
-      }[] = selectedUserReservesForMigration(get(), timestamp).map(
-        ({ underlyingAsset, underlyingBalance, reserve }) => {
-          const deadline = Math.floor(Date.now() / 1000 + 3600);
-          return {
-            amount: constants.MaxUint256.toString(),
-            aToken: reserve.aTokenAddress,
-            underlyingAsset: underlyingAsset,
-            // TODO: fow how long to approve?
-            deadline,
-          };
-        }
-      );
+      const borrowedPositions = selectUserBorrowReservesForMigration(get(), timestamp);
+      if (borrowedPositions.length > 0) {
+        return get().migrateBorrow();
+      }
+      const assets = selectUserSupplyAssetsForMigrationNoPermit(get(), timestamp);
       const user = get().account;
       return get().getMigrationServiceInstance().migrateNoBorrow({ assets, user });
     },
     migrateWithPermits: async (signatures: SignatureLike[], deadline: BigNumberish) => {
-      const permits = await Promise.all(
-        get().approvalPermitsForMigrationAssets.map(async ({ amount, underlyingAsset }, index) => {
-          return {
-            signedPermit: signatures[index],
-            deadline,
-            aToken: underlyingAsset,
-            value: amount,
-          };
-        })
+      const signedPermits = selectUserSupplyAssetsForMigrationWithPermits(
+        get(),
+        signatures,
+        deadline
       );
-      // branch out into flashloan or migrate no borrow
-      // move that to separate instance and save cache the Migrator instance
+      const borrowedPositions = selectUserBorrowReservesForMigration(get(), get().timestamp);
+      if (borrowedPositions.length > 0) {
+        return get().migrateBorrow(signedPermits);
+      }
+
       const migratorHelperInstance = get().getMigrationServiceInstance();
       const user = get().account;
-      const assets = selectedUserReservesForMigration(get(), get().timestamp).map(
+      const assets = selectedUserSupplyReservesForMigration(get(), get().timestamp).map(
         (reserve) => reserve.underlyingAsset
       );
-      await get()._testMigration();
-      console.log(assets);
       return migratorHelperInstance.migrateNoBorrowWithPermits({
         user,
         assets,
         deadline,
-        signedPermits: permits,
+        signedPermits,
       });
     },
     getMigratorAddress: () => {
@@ -201,20 +206,48 @@ export const createV3MigrationSlice: StateCreator<
       }
       const provider = get().jsonRpcProvider();
       const migratorAddress = get().getMigratorAddress();
-      const newMigratorInstance = new V3MigrationHelperService(provider, migratorAddress);
+      const currentMarketData = get().currentMarketData;
+      // TODO: make it dynamic when network switch will be there
+      const pool = new Pool(provider, {
+        POOL: '0x794a61358D6845594F94dc1DB02A252b5b4814aD',
+        REPAY_WITH_COLLATERAL_ADAPTER: currentMarketData.addresses.REPAY_WITH_COLLATERAL_ADAPTER,
+        SWAP_COLLATERAL_ADAPTER: currentMarketData.addresses.SWAP_COLLATERAL_ADAPTER,
+        WETH_GATEWAY: currentMarketData.addresses.WETH_GATEWAY,
+        L2_ENCODER: currentMarketData.addresses.L2_ENCODER,
+      });
+      const newMigratorInstance = new V3MigrationHelperService(provider, migratorAddress, pool);
       // TODO: don't forget to add maping here
       return newMigratorInstance;
     },
     _testMigration: async () => {
       const currentTimestamp = dayjs().unix();
-      const selectedReservers = selectedUserReservesForMigration(get(), currentTimestamp);
+      const selectedReservers = selectedUserSupplyReservesForMigration(get(), currentTimestamp);
       const mappedAddresses = await Promise.all(
         selectedReservers.map((reserve) =>
           get().getMigrationServiceInstance().testDeployment(reserve.underlyingAsset)
         )
       );
-
-      console.log(mappedAddresses);
+    },
+    migrateBorrow: async (signedPermits: V3MigrationHelperSignedPermit[] = []) => {
+      const currentTimestamp = dayjs().unix();
+      const user = get().account;
+      const suppliedPositions = selectUserSupplyAssetsForMigrationNoPermit(get(), currentTimestamp);
+      const borrowedPositions = selectUserBorrowReservesForMigration(get(), currentTimestamp);
+      const mappedBorrowPositions = borrowedPositions.map(
+        ({ increasedAmount, interestRate, underlyingAsset }) => {
+          return {
+            amount: increasedAmount,
+            interestRate,
+            address: underlyingAsset,
+          };
+        }
+      );
+      return get().getMigrationServiceInstance().migrateWithBorrow({
+        user,
+        borrowedPositions: mappedBorrowPositions,
+        suppliedPositions,
+        signedPermits,
+      });
     },
   };
 };
