@smartinvoicexyz/hooks/dist/src/useVerify.js

Unified source for React hooks used across the Smart Invoice protocol.

import { SMART_INVOICE_UPDATABLE_ABI, TOASTS, } from '@smartinvoicexyz/constants';
import { waitForSubgraphSync } from '@smartinvoicexyz/graphql';
import { errorToastHandler } from '@smartinvoicexyz/utils';
import { useCallback, useState } from 'react';
import { usePublicClient, useSimulateContract, useWriteContract } from 'wagmi';
export const useVerify = ({ address, chainId, toast, onTxSuccess, }) => {
    const publicClient = usePublicClient();
    const { data, error: prepareError, isLoading: prepareLoading, } = useSimulateContract({
        address,
        chainId,
        abi: SMART_INVOICE_UPDATABLE_ABI,
        functionName: 'verify', // no args
        query: {
            enabled: !!address,
        },
    });
    const [waitingForTx, setWaitingForTx] = useState(false);
    const { writeContractAsync, error: writeError, isPending: isLoading, } = useWriteContract({
        mutation: {
            onSuccess: async (hash) => {
                setWaitingForTx(true);
                toast.loading(TOASTS.useVerify.waitingForTx);
                const receipt = await publicClient?.waitForTransactionReceipt({ hash });
                toast.loading(TOASTS.useVerify.waitingForIndex);
                if (receipt && publicClient) {
                    await waitForSubgraphSync(publicClient.chain.id, receipt.blockNumber);
                }
                setWaitingForTx(false);
                onTxSuccess?.();
            },
            onError: error => errorToastHandler('useVerify', error, toast),
        },
    });
    const writeAsync = useCallback(async () => {
        try {
            if (!data) {
                throw new Error('simulation data is not available');
            }
            return writeContractAsync(data.request);
        }
        catch (error) {
            errorToastHandler('useVerify', error, toast);
            return undefined;
        }
    }, [writeContractAsync, data]);
    return {
        writeAsync,
        prepareError,
        writeError,
        isLoading: prepareLoading || isLoading || waitingForTx,
    };
};