feat: update flow for handling transactions (#1617)

src/__mocks__/models/contractTransaction.ts

@@ -0,0 +1,18 @@
+import { BigNumber as BN, ContractTransaction } from 'ethers';
+import { ChainId } from 'types';
+
+const contractTransaction: ContractTransaction = {
+  hash: 'fake-transaction-hash',
+  type: 1,
+  wait: vi.fn(),
+  confirmations: 0,
+  from: '0x1d759121234cd36F8124C21aFe1c6852d2bEd848',
+  to: '0x2d759121234cd36F8124C21aFe1c6852d2bEd834',
+  nonce: 10,
+  gasLimit: BN.from('100000000000'),
+  data: 'Fake data',
+  value: BN.from('0'),
+  chainId: ChainId.BSC_TESTNET,
+};
+
+export default contractTransaction;

src/__mocks__/models/provider.ts

@@ -7,10 +7,12 @@ export const balance = BigNumber.from('1000000000000000000');
 
 const getBlockNumber = vi.fn(async () => blockNumber);
 const getBalance = vi.fn(async () => balance);
+const waitForTransaction = vi.fn(async () => {});
 
 const provider = {
   getBlockNumber,
   getBalance,
+  waitForTransaction,
 } as unknown as Provider;
 
 export default provider;

src/clients/api/__mocks__/index.ts

@@ -33,10 +33,6 @@ export const getVaiTreasuryPercentage = vi.fn();
 export const useGetVaiTreasuryPercentage = () =>
   useQuery(FunctionKey.GET_VAI_TREASURY_PERCENTAGE, getVaiTreasuryPercentage);
 
-export const getMainAssetsInAccount = vi.fn();
-export const useGetMainAssetsInAccount = () =>
-  useQuery(FunctionKey.GET_MAIN_ASSETS_IN_ACCOUNT, getMainAssetsInAccount);
-
 export const getHypotheticalAccountLiquidity = vi.fn();
 
 export const getMainMarkets = vi.fn();

src/clients/api/index.ts

@@ -133,10 +133,6 @@ export { default as getVaiTreasuryPercentage } from './queries/getVaiTreasuryPer
 export * from './queries/getVaiTreasuryPercentage';
 export { default as useGetVaiTreasuryPercentage } from './queries/getVaiTreasuryPercentage/useGetVaiTreasuryPercentage';
 
-export { default as getMainAssetsInAccount } from './queries/getMainAssetsInAccount';
-export * from './queries/getMainAssetsInAccount';
-export { default as useGetMainAssetsInAccount } from './queries/getMainAssetsInAccount/useGetMainAssetsInAccount';
-
 export { default as getHypotheticalAccountLiquidity } from './queries/getHypotheticalAccountLiquidity';
 export * from './queries/getHypotheticalAccountLiquidity';
 

src/clients/api/mutations/approveToken/index.spec.ts

@@ -1,17 +1,14 @@
 import { Bep20 } from 'packages/contracts';
 
 import fakeAddress from '__mocks__/models/address';
-import fakeContractReceipt from '__mocks__/models/contractReceipt';
+import fakeContractTransaction from '__mocks__/models/contractTransaction';
 import MAX_UINT256 from 'constants/maxUint256';
 
 import approveToken from '.';
 
-describe('api/mutations/approveToken', () => {
+describe('approveToken', () => {
   test('returns contract receipt when request succeeds', async () => {
-    const waitMock = vi.fn(async () => fakeContractReceipt);
-    const approveTokenMock = vi.fn(() => ({
-      wait: waitMock,
-    }));
+    const approveTokenMock = vi.fn(async () => fakeContractTransaction);
 
     const fakeContract = {
       approve: approveTokenMock,
@@ -23,10 +20,8 @@ describe('api/mutations/approveToken', () => {
       allowance: MAX_UINT256.toFixed(),
     });
 
-    expect(response).toBe(fakeContractReceipt);
+    expect(response).toBe(fakeContractTransaction);
     expect(approveTokenMock).toHaveBeenCalledTimes(1);
     expect(approveTokenMock).toHaveBeenCalledWith(fakeAddress, MAX_UINT256.toFixed());
-    expect(waitMock).toBeCalledTimes(1);
-    expect(waitMock).toHaveBeenCalledWith(1);
   });
 });

src/clients/api/mutations/approveToken/index.ts

@@ -1,4 +1,4 @@
-import { ContractReceipt } from 'ethers';
+import { ContractTransaction } from 'ethers';
 import { Bep20, Vai, Vrt, Xvs } from 'packages/contracts';
 
 import MAX_UINT256 from 'constants/maxUint256';
@@ -9,15 +9,13 @@ export interface ApproveTokenInput {
   allowance?: string;
 }
 
-export type ApproveTokenOutput = ContractReceipt;
+export type ApproveTokenOutput = ContractTransaction;
 
 const approveToken = async ({
   tokenContract,
   spenderAddress,
   allowance = MAX_UINT256.toFixed(),
-}: ApproveTokenInput): Promise<ApproveTokenOutput> => {
-  const transaction = await tokenContract.approve(spenderAddress, allowance);
-  return transaction.wait(1);
-};
+}: ApproveTokenInput): Promise<ApproveTokenOutput> =>
+  tokenContract.approve(spenderAddress, allowance);
 
 export default approveToken;

src/clients/api/mutations/approveToken/useApproveToken.ts

@@ -1,47 +1,40 @@
 import { useGetTokenContract } from 'packages/contracts';
-import { MutationObserverOptions, useMutation } from 'react-query';
 import { Token } from 'types';
 import { callOrThrow } from 'utilities';
 
-import { ApproveTokenInput, ApproveTokenOutput, approveToken, queryClient } from 'clients/api';
+import { ApproveTokenInput, approveToken, queryClient } from 'clients/api';
 import FunctionKey from 'constants/functionKey';
+import { UseSendTransactionOptions, useSendTransaction } from 'hooks/useSendTransaction';
 
 type TrimmedApproveTokenInput = Omit<ApproveTokenInput, 'tokenContract'>;
-type Options = MutationObserverOptions<ApproveTokenOutput, Error, TrimmedApproveTokenInput>;
+type Options = UseSendTransactionOptions<TrimmedApproveTokenInput>;
 
 const useApproveToken = ({ token }: { token: Token }, options?: Options) => {
   const tokenContract = useGetTokenContract({ token, passSigner: true });
 
-  return useMutation(
-    [FunctionKey.APPROVE_TOKEN, { token }],
-    (input: TrimmedApproveTokenInput) =>
+  return useSendTransaction({
+    fnKey: [FunctionKey.APPROVE_TOKEN, { tokenAddress: token.address }],
+    fn: (input: TrimmedApproveTokenInput) =>
       callOrThrow({ tokenContract }, params =>
         approveToken({
           ...input,
           ...params,
         }),
       ),
-    {
-      ...options,
-      onSuccess: async (...onSuccessParams) => {
-        const { spenderAddress } = onSuccessParams[1];
-        const accountAddress = await tokenContract?.signer.getAddress();
+    onConfirmed: async ({ input }) => {
+      const accountAddress = await tokenContract?.signer.getAddress();
 
-        queryClient.invalidateQueries([
-          FunctionKey.GET_TOKEN_ALLOWANCE,
-          {
-            tokenAddress: token.address,
-            spenderAddress,
-            accountAddress,
-          },
-        ]);
-
-        if (options?.onSuccess) {
-          options.onSuccess(...onSuccessParams);
-        }
-      },
+      queryClient.invalidateQueries([
+        FunctionKey.GET_TOKEN_ALLOWANCE,
+        {
+          tokenAddress: token.address,
+          spenderAddress: input.spenderAddress,
+          accountAddress,
+        },
+      ]);
     },
-  );
+    options,
+  });
 };
 
 export default useApproveToken;

src/clients/api/mutations/borrow/index.spec.ts

@@ -1,20 +1,14 @@
 import BigNumber from 'bignumber.js';
-import { checkForTokenTransactionError } from 'errors';
 import { VBep20 } from 'packages/contracts';
 
-import fakeContractReceipt from '__mocks__/models/contractReceipt';
+import fakeContractTransaction from '__mocks__/models/contractTransaction';
 
 import borrow from '.';
 
-vi.mock('errors/transactionErrors');
-
-describe('api/mutation/borrow', () => {
+describe('borrow', () => {
   test('returns contract receipt when request succeeds', async () => {
     const fakeAmountWei = new BigNumber('10000000000000000');
-    const waitMock = vi.fn(async () => fakeContractReceipt);
-    const borrowMock = vi.fn(() => ({
-      wait: waitMock,
-    }));
+    const borrowMock = vi.fn(async () => fakeContractTransaction);
 
     const fakeContract = {
       borrow: borrowMock,
@@ -25,12 +19,8 @@ describe('api/mutation/borrow', () => {
       amountWei: fakeAmountWei,
     });
 
-    expect(response).toBe(fakeContractReceipt);
+    expect(response).toBe(fakeContractTransaction);
     expect(borrowMock).toHaveBeenCalledTimes(1);
     expect(borrowMock).toHaveBeenCalledWith(fakeAmountWei.toFixed());
-    expect(waitMock).toBeCalledTimes(1);
-    expect(waitMock).toHaveBeenCalledWith(1);
-    expect(checkForTokenTransactionError).toHaveBeenCalledTimes(1);
-    expect(checkForTokenTransactionError).toHaveBeenCalledWith(fakeContractReceipt);
   });
 });

src/clients/api/mutations/borrow/index.ts

@@ -1,19 +1,15 @@
 import BigNumber from 'bignumber.js';
-import { checkForTokenTransactionError } from 'errors';
-import { ContractReceipt } from 'ethers';
+import { ContractTransaction } from 'ethers';
 import { VBep20, VBnb } from 'packages/contracts';
 
 export interface BorrowInput {
   vTokenContract: VBep20 | VBnb;
   amountWei: BigNumber;
 }
 
-export type BorrowOutput = ContractReceipt;
+export type BorrowOutput = ContractTransaction;
 
-const borrow = async ({ vTokenContract, amountWei }: BorrowInput): Promise<BorrowOutput> => {
-  const transaction = await vTokenContract.borrow(amountWei.toFixed());
-  const receipt = await transaction.wait(1);
-  return checkForTokenTransactionError(receipt);
-};
+const borrow = async ({ vTokenContract, amountWei }: BorrowInput): Promise<BorrowOutput> =>
+  vTokenContract.borrow(amountWei.toFixed());
 
 export default borrow;

src/clients/api/mutations/borrow/useBorrow.ts

@@ -1,14 +1,14 @@
 import { useAnalytics } from 'packages/analytics';
 import { useGetVTokenContract } from 'packages/contracts';
-import { MutationObserverOptions, useMutation } from 'react-query';
 import { VToken } from 'types';
 import { callOrThrow, convertWeiToTokens } from 'utilities';
 
-import { BorrowInput, BorrowOutput, borrow, queryClient } from 'clients/api';
+import { BorrowInput, borrow, queryClient } from 'clients/api';
 import FunctionKey from 'constants/functionKey';
+import { UseSendTransactionOptions, useSendTransaction } from 'hooks/useSendTransaction';
 
 type TrimmedBorrowInput = Omit<BorrowInput, 'vTokenContract'>;
-type Options = MutationObserverOptions<BorrowOutput, Error, TrimmedBorrowInput>;
+type Options = UseSendTransactionOptions<TrimmedBorrowInput>;
 
 const useBorrow = (
   { vToken, poolName }: { vToken: VToken; poolName: string },
@@ -17,48 +17,41 @@ const useBorrow = (
   const vTokenContract = useGetVTokenContract({ vToken, passSigner: true });
   const { captureAnalyticEvent } = useAnalytics();
 
-  return useMutation(
-    [FunctionKey.BORROW, { vToken }],
-    (input: TrimmedBorrowInput) =>
+  return useSendTransaction({
+    fnKey: [FunctionKey.BORROW, { vToken }],
+    fn: (input: TrimmedBorrowInput) =>
       callOrThrow({ vTokenContract }, params =>
         borrow({
           ...params,
           ...input,
         }),
       ),
-    {
-      ...options,
-      onSuccess: async (...onSuccessParams) => {
-        const { amountWei } = onSuccessParams[1];
-
-        captureAnalyticEvent('Tokens borrowed', {
-          poolName,
-          tokenSymbol: vToken.underlyingToken.symbol,
-          tokenAmountTokens: convertWeiToTokens({
-            token: vToken.underlyingToken,
-            valueWei: amountWei,
-          }).toNumber(),
-        });
-
-        const accountAddress = await vTokenContract?.signer.getAddress();
-
-        queryClient.invalidateQueries(FunctionKey.GET_V_TOKEN_BALANCES_ALL);
-        queryClient.invalidateQueries([
-          FunctionKey.GET_BALANCE_OF,
-          {
-            accountAddress,
-            vTokenAddress: vToken.address,
-          },
-        ]);
-        queryClient.invalidateQueries(FunctionKey.GET_MAIN_MARKETS);
-        queryClient.invalidateQueries(FunctionKey.GET_ISOLATED_POOLS);
-
-        if (options?.onSuccess) {
-          options.onSuccess(...onSuccessParams);
-        }
-      },
+    onConfirmed: async ({ input }) => {
+      captureAnalyticEvent('Tokens borrowed', {
+        poolName,
+        tokenSymbol: vToken.underlyingToken.symbol,
+        tokenAmountTokens: convertWeiToTokens({
+          token: vToken.underlyingToken,
+          valueWei: input.amountWei,
+        }).toNumber(),
+      });
+
+      const accountAddress = await vTokenContract?.signer.getAddress();
+
+      queryClient.invalidateQueries(FunctionKey.GET_V_TOKEN_BALANCES_ALL);
+      queryClient.invalidateQueries([
+        FunctionKey.GET_BALANCE_OF,
+        {
+          accountAddress,
+          vTokenAddress: vToken.address,
+        },
+      ]);
+      queryClient.invalidateQueries(FunctionKey.GET_MAIN_MARKETS);
+      queryClient.invalidateQueries(FunctionKey.GET_MAIN_POOL);
+      queryClient.invalidateQueries(FunctionKey.GET_ISOLATED_POOLS);
     },
-  );
+    options,
+  });
 };
 
 export default useBorrow;

src/clients/api/mutations/claimRewards/index.ts

@@ -116,6 +116,7 @@ const claimRewards = async ({
   const receipt = await transaction.wait(1);
 
   // Check for errors that did not revert the transaction
+  // TODO: remove once this function has been refactored to use useSendTransaction hook
   checkForComptrollerTransactionError(receipt);
   checkForTokenTransactionError(receipt);
   checkForVaiControllerTransactionError(receipt);

src/clients/api/mutations/enterMarket/index.ts

@@ -16,6 +16,7 @@ const enterMarket = async ({
 }: EnterMarketInput): Promise<EnterMarketOutput> => {
   const transaction = await comptrollerContract.enterMarkets([vToken.address]);
   const receipt = await transaction.wait(1);
+  // TODO: remove check once this function has been refactored to use useSendTransaction hook
   return checkForComptrollerTransactionError(receipt);
 };
 

src/clients/api/mutations/enterMarket/useEnterMarket.ts

@@ -29,7 +29,7 @@ const useEnterMarket = (
         userSupplyBalanceTokens: userSupplyBalanceTokens.toNumber(),
       });
 
-      queryClient.invalidateQueries(FunctionKey.GET_MAIN_ASSETS_IN_ACCOUNT);
+      queryClient.invalidateQueries(FunctionKey.GET_MAIN_POOL);
       queryClient.invalidateQueries(FunctionKey.GET_ISOLATED_POOLS);
 
       if (options?.onSuccess) {

src/clients/api/mutations/executeWithdrawalFromXvsVault/index.tsx

@@ -17,6 +17,7 @@ const executeWithdrawalFromXvsVault = async ({
 }: ExecuteWithdrawalFromXvsVaultInput): Promise<ExecuteWithdrawalFromXvsVaultOutput> => {
   const transaction = await xvsVaultContract.executeWithdrawal(rewardTokenAddress, poolIndex);
   const receipt = await transaction.wait(1);
+  // TODO: remove check once this function has been refactored to use useSendTransaction hook
   return checkForXvsVaultProxyTransactionError(receipt);
 };
 

src/clients/api/mutations/exitMarket/index.ts

@@ -16,6 +16,7 @@ const exitMarket = async ({
 }: ExitMarketInput): Promise<ExitMarketOutput> => {
   const transaction = await comptrollerContract.exitMarket(vToken.address);
   const receipt = await transaction.wait(1);
+  // TODO: remove check once this function has been refactored to use useSendTransaction hook
   return checkForComptrollerTransactionError(receipt);
 };
 

src/clients/api/mutations/exitMarket/useExitMarket.ts

@@ -29,7 +29,7 @@ const useExitMarket = (
         userSupplyBalanceTokens: userSupplyBalanceTokens.toNumber(),
       });
 
-      queryClient.invalidateQueries(FunctionKey.GET_MAIN_ASSETS_IN_ACCOUNT);
+      queryClient.invalidateQueries(FunctionKey.GET_MAIN_POOL);
       queryClient.invalidateQueries(FunctionKey.GET_ISOLATED_POOLS);
 
       if (options?.onSuccess) {

src/clients/api/mutations/mintVai/index.ts

@@ -16,6 +16,7 @@ const mintVai = async ({
 }: MintVaiInput): Promise<MintVaiOutput> => {
   const transaction = await vaiControllerContract.mintVAI(amountWei.toFixed());
   const receipt = await transaction.wait(1);
+  // TODO: remove check once this function has been refactored to use useSendTransaction hook
   return checkForVaiControllerTransactionError(receipt);
 };