Re-using write/simulate hooks generic types

[Yuripetusko]

I have a code that I keep repeating over and over for different contract functions write hooks. it consists of useSimulateContract and then useWriteContract, useWaitForTransactionReceipt, and then some extra repetitive code like const isLoading = isLoadingReceipt || isLoadingPrepare || isLoadingWrite || isFetchingReceipt;

I am trying to make it into it's own wrapper-hook, where I can pass a useSimulateContract config as a generic type, and for this wrapper hook return value to be config (abi, functionName, etc) aware. I might have looked at the code for too longm now, but so far having no luck. Tried different combinations of UseSimulateContractParameters as well as Parameters and UseSimulateContractReturnType to no avail. I'll keep trying to make this work, but was wondering if anyone tried anything similar and had a success.

here's a quick example of me trying to make it work https://stackblitz.com/edit/new-wagmi-rzlztm?file=src%2Fuse-wrapped-contract-write.ts

particulary this part

export const useWrappedContractWrite = <
  const abi extends Abi | readonly unknown[],
  functionName extends ContractFunctionName<abi, 'nonpayable' | 'payable'>,
  args extends ContractFunctionArgs<abi, 'nonpayable' | 'payable', functionName>,
  config extends Config = ResolvedRegister['config'],
  chainId extends config['chains'][number]['id'] | undefined = undefined,
  selectData = SimulateContractData<abi, functionName, args, config, chainId>,
>({
  config = {} as any,
  options,
}: {
  config: UseSimulateContractParameters<abi, functionName, args, config, chainId, selectData>;
  options: {
    enabled?: boolean;
    onError?: (error?: BaseError | Error | null) => void;
    onSuccess?: (data: TransactionReceipt) => void;
    onSettled?: (data?: TransactionReceipt) => void;
  };
}) => {

Then when trying to pass such config to useSimulateContract, args are incompatible for example

[nejcm]

I am dealing with a similar situation where I am trying to make reusable hooks that wrap common functionality and than pass in the query parameter to override or extend it. v2 made this more hard as it's hard to find out how to setup these generic types.

A very simple example of how v2 made typings a bit strange/harder is also with with using the useWriteContract. That hook can have the onSuccess callback inside the mutation argument. But now because this hooks was made more generic where the actual contract and function name are specified at the contract call I have to construct these types on the onSuccess callback myself instead of having that done by the hook itself even though this hook gets called only for that specific contract method in my case.

While I appreciate the versatility this brings, to me it's usually not the way I am using these hooks as each one is used usually only for a specific contract call (even recommended by the react-query team because if one mutation is reused across multiple things you run into problem with loading states...). But I guess adding a reusable hook that would do that is not hard but than we run into the hassle of the types mentioned above.