chore: structure

Author: Jeday

features/create-vault/create-vault-form/submit-modal/submit-modal.tsx

@@ -104,7 +104,7 @@ export const SubmitModal: FC<ModalProps> = () => {
           SubmitStepEnum.submitting === step) &&
           tx && <TxLinkEtherscan txHash={tx} />}
 
-        {step === SubmitStepEnum.reject && (
+        {step === SubmitStepEnum.reject && retryFire && (
           <ButtonLink onClick={retryFire}>Retry</ButtonLink>
         )}
 

features/supply/fund/fund-form-context/fund-form-provider.tsx

@@ -18,7 +18,7 @@ export const FundFormProvider: FC<{ children: ReactNode }> = ({ children }) => {
     reValidateMode: 'onChange',
   });
 
-  const { fund, retryFire } = useFund();
+  const { fund, retryEvent } = useFund();
 
   const onSubmit = useCallback(
     async ({ amount }: FundFormSchema) => {
@@ -32,10 +32,10 @@ export const FundFormProvider: FC<{ children: ReactNode }> = ({ children }) => {
     useMemo(
       () => ({
         onSubmit,
-        retryFire,
+        retryEvent,
         onReset: formObject.reset,
       }),
-      [retryFire, onSubmit, formObject.reset],
+      [onSubmit, retryEvent, formObject.reset],
     );
 
   return (

features/supply/fund/hooks/use-fund.ts

@@ -10,7 +10,7 @@ import {
   TransactionEntry,
   useSendTransaction,
   withSuccess,
-} from 'modules/web3/hooks/use-send-tx';
+} from 'modules/web3';
 
 export const useFund = () => {
   const { activeVault } = useVaultInfo();

features/supply/withdraw/form/submit-button/submit-button.tsx

@@ -1,4 +1,3 @@
-import { OracleReportButton } from 'features/report';
 import { PermissionedSubmitButton } from 'modules/vaults/components';
 
 import { useFormContext } from 'react-hook-form';
@@ -10,14 +9,12 @@ export const SubmitButton = () => {
   const disabled = isSubmitting || !isValid || !isDirty;
 
   return (
-    <OracleReportButton action="withdrawal">
-      <PermissionedSubmitButton
-        type="submit"
-        dashboardRole="withdrawer"
-        disabled={disabled}
-      >
-        Withdraw
-      </PermissionedSubmitButton>
-    </OracleReportButton>
+    <PermissionedSubmitButton
+      type="submit"
+      dashboardRole="withdrawer"
+      disabled={disabled}
+    >
+      Withdraw
+    </PermissionedSubmitButton>
   );
 };

features/supply/withdraw/hooks/use-withdraw.ts

@@ -1,60 +1,93 @@
 import { useCallback } from 'react';
-import { useEstimateGas, usePublicClient, useWriteContract } from 'wagmi';
+import { useEstimateGas, usePublicClient } from 'wagmi';
 import { Address, encodeFunctionData } from 'viem';
 
 import { dashboardAbi } from 'abi/dashboard-abi';
 import { useDappStatus } from 'modules/web3/hooks/use-dapp-status';
 import { useVaultInfo } from 'modules/vaults';
 import invariant from 'tiny-invariant';
 import { useVaultPermission } from 'modules/vaults/hooks/use-vault-permissions';
-import {
-  SubmitPayload,
-  SubmitStepEnum,
-} from 'shared/components/submit-modal/types';
+
 import { fallbackedAddress } from 'utils/fallbacked-address';
+import {
+  TransactionEntry,
+  useSendTransaction,
+  withSuccess,
+} from 'modules/web3';
+import { useReportStatus } from 'features/report/use-report';
+import { fetchReportMerkle } from 'features/report/ipfs';
+import { getVaultHubContract } from 'modules/vaults/contracts/vault-hub';
 
 type WithdrawArgs = {
   recipient: Address;
   amount: bigint;
-  setModalState: (submitStep: SubmitPayload) => void;
 };
 
-export const useWithdraw = (onMutate = () => {}) => {
+export const useWithdraw = () => {
   const { activeVault } = useVaultInfo();
   const publicClient = usePublicClient();
+  const { sendTX, ...rest } = useSendTransaction();
+  const { shouldApplyReport } = useReportStatus();
 
-  const { data: withdrawTx, writeContractAsync } = useWriteContract({
-    mutation: {
-      onMutate,
-    },
-  });
-
-  const callWithdraw = useCallback(
-    async ({ amount, recipient, setModalState }: WithdrawArgs) => {
+  const withdraw = useCallback(
+    async ({ amount, recipient }: WithdrawArgs) => {
       invariant(activeVault, '[useWithdraw] activeVault is undefined');
       invariant(publicClient, '[useWithdraw] publicClient is undefined');
 
-      setModalState({ step: SubmitStepEnum.confirming });
-      const tx = await writeContractAsync({
-        abi: dashboardAbi,
-        address: activeVault.owner,
-        functionName: 'withdraw',
-        args: [recipient, amount],
-      });
+      const transactions: TransactionEntry[] = [];
+
+      if (shouldApplyReport) {
+        const hub = getVaultHubContract(publicClient);
+        const reportCid = (await hub.read.latestReportData())[2];
+
+        const report = await fetchReportMerkle(
+          publicClient.chain.id,
+          reportCid,
+          activeVault.address,
+        );
+
+        transactions.push({
+          loadingActionText: 'Applying oracle report',
+          to: hub.address,
+          data: encodeFunctionData({
+            abi: hub.abi,
+            functionName: 'updateVaultData',
+            args: [
+              activeVault.address,
+              report.totalValueWei,
+              report.inOutDelta,
+              report.fee,
+              report.liabilityShares,
+              report.proof,
+            ],
+          }),
+        });
+      }
 
-      setModalState({ step: SubmitStepEnum.submitting, tx });
-      await publicClient.waitForTransactionReceipt({
-        hash: tx,
+      transactions.push({
+        loadingActionText: 'Withdrawing ETH from vault',
+        to: activeVault.owner,
+        data: encodeFunctionData({
+          abi: dashboardAbi,
+          functionName: 'withdraw',
+          args: [recipient, amount],
+        }),
       });
 
-      return tx;
+      return withSuccess(
+        sendTX({
+          transactions,
+          mainActionLoadingText: 'Withdrawing ETH from vault',
+          mainActionCompleteText: 'ETH withdrawn from vault',
+        }),
+      );
     },
-    [activeVault, writeContractAsync, publicClient],
+    [activeVault, publicClient, shouldApplyReport, sendTX],
   );
 
   return {
-    callWithdraw,
-    withdrawTx,
+    withdraw,
+    ...rest,
   };
 };
 

features/supply/withdraw/withdraw-form-context/withdraw-form-provider.tsx

@@ -5,28 +5,20 @@ import {
   useCallback,
   createContext,
   useContext,
-  useState,
 } from 'react';
 import { FormProvider, useForm } from 'react-hook-form';
-import { Address, isAddress } from 'viem';
+import type { Address } from 'viem';
 import invariant from 'tiny-invariant';
 
-import { useFormControllerRetry } from 'shared/hook-form/form-controller/use-form-controller-retry-delegate';
 import { useWithdrawable, useWithdraw } from 'features/supply/withdraw/hooks';
 
 import {
   FormController,
   FormControllerContext,
   FormControllerContextValueType,
 } from 'shared/hook-form/form-controller';
-import { SubmitModal } from 'shared/components';
 
 import { WithdrawFormSchema } from 'features/supply/withdraw/types';
-import {
-  SubmitPayload,
-  SubmitStep,
-  SubmitStepEnum,
-} from 'shared/components/submit-modal/types';
 
 type WithdrawDataContextValue = {
   withdrawableAmount: bigint | undefined;
@@ -53,10 +45,6 @@ export const useWithdrawFormData = () => {
 export const WithdrawFormProvider: FC<{ children: ReactNode }> = ({
   children,
 }) => {
-  const [submitStep, setSubmitStep] = useState<{
-    step: SubmitStep;
-    tx?: Address;
-  }>(() => ({ step: SubmitStepEnum.edit }));
   const formObject = useForm<WithdrawFormSchema>({
     defaultValues: {
       amount: undefined,
@@ -65,11 +53,7 @@ export const WithdrawFormProvider: FC<{ children: ReactNode }> = ({
     mode: 'all',
     reValidateMode: 'onChange',
   });
-  const { callWithdraw } = useWithdraw();
-  const { retryEvent, retryFire } = useFormControllerRetry();
-  const setModalState = useCallback((submitStep: SubmitPayload) => {
-    setSubmitStep(submitStep);
-  }, []);
+  const { withdraw, retryEvent } = useWithdraw();
 
   const {
     data: withdrawableAmount,
@@ -95,49 +79,34 @@ export const WithdrawFormProvider: FC<{ children: ReactNode }> = ({
 
   const onSubmit = useCallback(
     async ({ amount, recipient }: WithdrawFormSchema) => {
-      try {
-        if (amount && recipient && isAddress(recipient)) {
-          setModalState({ step: SubmitStepEnum.initiate });
-          const tx = await callWithdraw({ amount, recipient, setModalState });
-          setModalState({ step: SubmitStepEnum.overview, tx });
-          return true;
-        }
-      } catch (err) {
-        if (
-          err instanceof Error &&
-          err.message.includes('User rejected the request')
-        ) {
-          setModalState({ step: SubmitStepEnum.reject });
-        } else {
-          setModalState({ step: SubmitStepEnum.error });
-        }
+      invariant(
+        amount,
+        '[WithdrawFormProvider] withdrawableAmount is undefined',
+      );
+      invariant(recipient, '[WithdrawFormProvider] recipient is undefined');
 
-        return false;
-      }
+      const { success } = await withdraw({ amount, recipient });
 
-      return false;
+      return success;
     },
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    [callWithdraw],
+    [withdraw],
   );
 
   const formControllerValue: FormControllerContextValueType<WithdrawFormSchema> =
     useMemo(
       () => ({
         onSubmit,
         retryEvent,
-        retryFire,
         onReset: formObject.reset,
       }),
-      [retryFire, retryEvent, onSubmit, formObject.reset],
+      [retryEvent, onSubmit, formObject.reset],
     );
 
   return (
     <WithdrawDataContext.Provider value={withdrawData}>
       <FormProvider {...formObject}>
         <FormControllerContext.Provider value={formControllerValue}>
           <FormController>{children}</FormController>
-          <SubmitModal submitStep={submitStep} setModalState={setModalState} />
         </FormControllerContext.Provider>
       </FormProvider>
     </WithdrawDataContext.Provider>

modules/web3/hooks/index.ts

@@ -8,3 +8,4 @@ export * from './use-wstETH-by-stETH';
 export * from './use-stETH-by-wstETH';
 export * from './use-is-metamask';
 export * from './use-aa';
+export * from './use-send-tx';