writeContractAsync parameters are not inferred correctly

[0xGh]

I am writing a React hook to combine writeContractAsync and waitForTransactionReceipt. This is because most of the times my frontend needs to wait for the tx to be confirmed and status must reflect that i.e. it must be pending until confirmed.

The implementation works however I am facing an issue related to the parameters' type inference.

const writeAndWaitForReceipt = useCallback(
    async function writeAndWaitForReceipt(
      ...params: Parameters<typeof writeContractAsync>
    ): Promise<{ hash: Hash; receipt: TransactionReceipt }> {
    }
)

With Parameters<typeof writeContractAsync> when I use writeAndWaitForReceipt, params[0] are broken. Eg. abi args are not inferred (foo doesn't exist and typescript should report this as an error) and value is not recognized as a valid param.

Whereas when I type writeAndWaitForReceipt as typeof writeContractAsync types are inferred correctly but of course now the return type must be writeContractAsync's rather than Promise<{ hash: Hash; receipt: TransactionReceipt }> which is what I want.

Any idea about why this is happening?

Full hook implementation:

import { useState, useCallback } from "react";
import { waitForTransactionReceipt } from "@wagmi/core";
import { useWriteContract, useConfig } from "wagmi";
import {
  UserRejectedRequestError,
  type Hash,
  type TransactionReceipt,
} from "viem";

export function useWriteAndWaitForReceipt() {
  const config = useConfig();

  const {
    writeContractAsync,
    writeContract,
    status: originalStatus,
    reset,
    ...writeContractRest
  } = useWriteContract();

  const [status, setStatus] = useState<typeof originalStatus>("idle");

  const [receipt, setReceipt] = useState<TransactionReceipt>();

  // Ideally we want writeAndWaitForReceipt
  // to accept the same variables (first argument of writeContractAsync)
  // and define custom onSuccess,onError,onSettled
  // as well as return {hash, receipt} instead of just hash
  // @todo figure out why Parameters<typeof writeContractAsync> messes up type inference.
  const writeAndWaitForReceipt = useCallback(
    async function writeAndWaitForReceipt(
      ...params: Parameters<typeof writeContractAsync>
    ): Promise<{ hash: Hash; receipt: TransactionReceipt }> {
      setStatus("pending");
      try {
        const hash = await writeContractAsync(params[0]);
        const receipt = await waitForTransactionReceipt(config, { hash });
        setReceipt(receipt);
        setStatus("success");
        return { hash, receipt };
      } catch (error) {
        setStatus(error instanceof UserRejectedRequestError ? "idle" : "error");
        throw error;
      }
    },
    [writeContractAsync, config],
  );

  return {
    ...writeContractRest,
    reset: () => {
      setReceipt(undefined);
      setStatus("idle");
      reset();
    },
    writeAndWaitForReceipt,
    status,
    receipt,
  };
}

export type UseWriteAndWaitForReceipt = ReturnType<
  typeof useWriteAndWaitForReceipt
>;