wagmi 3.0.2 → 3.1.0

package/src/hooks/codegen/createUseWriteContract.ts

@@ -63,6 +63,81 @@ export type CreateUseWriteContractReturnType<
     wagmi_UseWriteContractReturnType<config, context>,
     'writeContract' | 'writeContractAsync'
   > & {
+    mutate: <
+      const abi2 extends abi,
+      name extends functionName extends ContractFunctionName<
+        abi,
+        stateMutability
+      >
+        ? functionName
+        : ContractFunctionName<abi, stateMutability>,
+      args extends ContractFunctionArgs<abi2, stateMutability, name>,
+      chainId extends config['chains'][number]['id'],
+    >(
+      variables: Variables<
+        abi2,
+        functionName,
+        name,
+        args,
+        config,
+        chainId,
+        address
+      >,
+      options?:
+        | MutateOptions<
+            WriteContractData,
+            WriteContractErrorType,
+            WriteContractVariables<
+              abi2,
+              name,
+              args,
+              config,
+              chainId,
+              // use `functionName` to make sure it's not union of all possible function names
+              name
+            >,
+            context
+          >
+        | undefined,
+    ) => void
+    mutateAsync: <
+      const abi2 extends abi,
+      name extends functionName extends ContractFunctionName<
+        abi,
+        stateMutability
+      >
+        ? functionName
+        : ContractFunctionName<abi, stateMutability>,
+      args extends ContractFunctionArgs<abi2, stateMutability, name>,
+      chainId extends config['chains'][number]['id'],
+    >(
+      variables: Variables<
+        abi2,
+        functionName,
+        name,
+        args,
+        config,
+        chainId,
+        address
+      >,
+      options?:
+        | MutateOptions<
+            WriteContractData,
+            WriteContractErrorType,
+            WriteContractVariables<
+              abi2,
+              name,
+              args,
+              config,
+              chainId,
+              // use `functionName` to make sure it's not union of all possible function names
+              name
+            >,
+            context
+          >
+        | undefined,
+    ) => Promise<WriteContractData>
+    /** @deprecated use `mutate` instead */
     writeContract: <
       const abi2 extends abi,
       name extends functionName extends ContractFunctionName<
@@ -100,6 +175,7 @@ export type CreateUseWriteContractReturnType<
           >
         | undefined,
     ) => void
+    /** @deprecated use `mutateAsync` instead */
     writeContractAsync: <
       const abi2 extends abi,
       name extends functionName extends ContractFunctionName<
@@ -158,76 +234,78 @@ export function createUseWriteContract<
       const result = useWriteContract(parameters)
       const configChainId = useChainId({ config })
       type Args = Parameters<wagmi_UseWriteContractReturnType['writeContract']>
-      return {
-        ...(result as any),
-        writeContract: useCallback(
-          (...args: Args) => {
-            const chainId = (() => {
-              if (args[0].chainId) return args[0].chainId
-              return configChainId
-            })()
-            const variables = {
-              ...(args[0] as any),
-              address: chainId ? props.address?.[chainId] : undefined,
-              ...(props.functionName
-                ? { functionName: props.functionName }
-                : {}),
-              abi: props.abi,
-            }
-            result.writeContract(variables, args[1] as any)
-          },
-          [props, configChainId, result.writeContract],
-        ),
-        writeContractAsync: useCallback(
-          (...args: Args) => {
-            const chainId = (() => {
-              if (args[0].chainId) return args[0].chainId
-              return configChainId
-            })()
-            const variables = {
-              ...(args[0] as any),
-              address: chainId ? props.address?.[chainId] : undefined,
-              ...(props.functionName
-                ? { functionName: props.functionName }
-                : {}),
-              abi: props.abi,
-            }
-            return result.writeContractAsync(variables, args[1] as any)
-          },
-          [props, configChainId, result.writeContractAsync],
-        ),
-      }
-    }
-
-  return (parameters) => {
-    const result = useWriteContract(parameters)
-    type Args = Parameters<wagmi_UseWriteContractReturnType['writeContract']>
-    return {
-      ...(result as any),
-      writeContract: useCallback(
+      const mutate = useCallback(
         (...args: Args) => {
+          const chainId = (() => {
+            if (args[0].chainId) return args[0].chainId
+            return configChainId
+          })()
           const variables = {
             ...(args[0] as any),
-            ...(props.address ? { address: props.address } : {}),
+            address: chainId ? props.address?.[chainId] : undefined,
             ...(props.functionName ? { functionName: props.functionName } : {}),
             abi: props.abi,
           }
           result.writeContract(variables, args[1] as any)
         },
-        [props, result.writeContract],
-      ),
-      writeContractAsync: useCallback(
+        [props, configChainId, result.writeContract],
+      )
+      const mutateAsync = useCallback(
         (...args: Args) => {
+          const chainId = (() => {
+            if (args[0].chainId) return args[0].chainId
+            return configChainId
+          })()
           const variables = {
             ...(args[0] as any),
-            ...(props.address ? { address: props.address } : {}),
+            address: chainId ? props.address?.[chainId] : undefined,
             ...(props.functionName ? { functionName: props.functionName } : {}),
             abi: props.abi,
           }
           return result.writeContractAsync(variables, args[1] as any)
         },
-        [props, result.writeContractAsync],
-      ),
+        [props, configChainId, result.writeContractAsync],
+      )
+      return {
+        ...(result as any),
+        mutate,
+        mutateAsync,
+        writeContract: mutate,
+        writeContractAsync: mutateAsync,
+      }
+    }
+
+  return (parameters) => {
+    const result = useWriteContract(parameters)
+    type Args = Parameters<wagmi_UseWriteContractReturnType['writeContract']>
+    const mutate = useCallback(
+      (...args: Args) => {
+        const variables = {
+          ...(args[0] as any),
+          ...(props.address ? { address: props.address } : {}),
+          ...(props.functionName ? { functionName: props.functionName } : {}),
+          abi: props.abi,
+        }
+        result.mutate(variables, args[1] as any)
+      },
+      [props, result.mutate],
+    )
+    const mutateAsync = useCallback(
+      (...args: Args) => {
+        const variables = {
+          ...(args[0] as any),
+          ...(props.address ? { address: props.address } : {}),
+          ...(props.functionName ? { functionName: props.functionName } : {}),
+          abi: props.abi,
+        }
+        return result.mutateAsync(variables, args[1] as any)
+      },
+      [props, result.mutateAsync],
+    )
+    return {
+      ...(result as any),
+      writeContract: mutate,
+      writeContractAsync: mutateAsync,
     }
   }
 }

package/src/hooks/useConnect.ts

@@ -46,10 +46,14 @@ export type UseConnectReturnType<
     ConnectVariables<config, config['connectors'][number], boolean>,
     context
   > & {
+    /** @deprecated use `mutate` instead */
     connect: ConnectMutate<config, context>
+    /** @deprecated use `mutateAsync` instead */
     connectAsync: ConnectMutateAsync<config, context>
     /** @deprecated use `useConnectors` instead */
     connectors: Compute<UseConnectorsReturnType> | config['connectors']
+    mutate: ConnectMutate<config, context>
+    mutateAsync: ConnectMutateAsync<config, context>
   }
 >
 
@@ -60,13 +64,11 @@ export function useConnect<
 >(
   parameters: UseConnectParameters<config, context> = {},
 ): UseConnectReturnType<config, context> {
-  const { mutation } = parameters
-
   const config = useConfig(parameters)
 
   const mutationOptions = connectMutationOptions(config)
-  const { mutate, mutateAsync, ...result } = useMutation({
-    ...(mutation as typeof mutationOptions),
+  const mutation = useMutation({
+    ...(parameters.mutation as typeof mutationOptions),
     ...mutationOptions,
   })
 
@@ -76,16 +78,16 @@ export function useConnect<
       ({ status }) => status,
       (status, previousStatus) => {
         if (previousStatus === 'connected' && status === 'disconnected')
-          result.reset()
+          mutation.reset()
       },
     )
-  }, [config, result.reset])
+  }, [config, mutation.reset])
 
   type Return = UseConnectReturnType<config, context>
   return {
-    ...(result as Return),
-    connect: mutate as Return['connect'],
-    connectAsync: mutateAsync as Return['connectAsync'],
+    ...(mutation as Return),
+    connect: mutation.mutate as Return['mutate'],
+    connectAsync: mutation.mutateAsync as Return['mutateAsync'],
     connectors: useConnectors({ config }),
   }
 }

package/src/hooks/useDeployContract.ts

@@ -48,8 +48,12 @@ export type UseDeployContractReturnType<
   DeployContractVariables<Abi, config, config['chains'][number]['id']>,
   context
 > & {
+  /** @deprecated use `mutate` instead */
   deployContract: DeployContractMutate<config, context>
+  /** @deprecated use `mutateAsync` instead */
   deployContractAsync: DeployContractMutateAsync<config, context>
+  mutate: DeployContractMutate<config, context>
+  mutateAsync: DeployContractMutateAsync<config, context>
 }
 
 /** https://wagmi.sh/react/api/hooks/useDeployContract */
@@ -59,20 +63,15 @@ export function useDeployContract<
 >(
   parameters: UseDeployContractParameters<config, context> = {},
 ): UseDeployContractReturnType<config, context> {
-  const { mutation } = parameters
-
   const config = useConfig(parameters)
-
   const mutationOptions = deployContractMutationOptions(config)
-  const { mutate, mutateAsync, ...result } = useMutation({
-    ...mutation,
-    ...mutationOptions,
-  })
-
+  const mutation = useMutation({ ...parameters.mutation, ...mutationOptions })
   type Return = UseDeployContractReturnType<config, context>
   return {
-    ...result,
-    deployContract: mutate as Return['deployContract'],
-    deployContractAsync: mutateAsync as Return['deployContractAsync'],
+    ...mutation,
+    deployContract: mutation.mutate as Return['mutate'],
+    deployContractAsync: mutation.mutateAsync as Return['mutateAsync'],
+    mutate: mutation.mutate as Return['mutate'],
+    mutateAsync: mutation.mutateAsync as Return['mutateAsync'],
   }
 }

package/src/hooks/useDisconnect.ts

@@ -41,8 +41,12 @@ export type UseDisconnectReturnType<context = unknown> = Compute<
   > & {
     /** @deprecated use `useConnections` instead */
     connectors: readonly Connector[]
+    /** @deprecated use `mutate` instead */
     disconnect: DisconnectMutate<context>
+    /** @deprecated use `mutateAsync` instead */
     disconnectAsync: DisconnectMutateAsync<context>
+    mutate: DisconnectMutate<context>
+    mutateAsync: DisconnectMutateAsync<context>
   }
 >
 
@@ -50,22 +54,15 @@ export type UseDisconnectReturnType<context = unknown> = Compute<
 export function useDisconnect<context = unknown>(
   parameters: UseDisconnectParameters<context> = {},
 ): UseDisconnectReturnType<context> {
-  const { mutation } = parameters
-
   const config = useConfig(parameters)
-
   const mutationOptions = disconnectMutationOptions(config)
-  const { mutate, mutateAsync, ...result } = useMutation({
-    ...mutation,
-    ...mutationOptions,
-  })
-
+  const mutation = useMutation({ ...parameters.mutation, ...mutationOptions })
   return {
-    ...result,
+    ...mutation,
     connectors: useConnections({ config }).map(
       (connection) => connection.connector,
     ),
-    disconnect: mutate,
-    disconnectAsync: mutateAsync,
+    disconnect: mutation.mutate,
+    disconnectAsync: mutation.mutateAsync,
   }
 }

package/src/hooks/useReconnect.ts

@@ -39,7 +39,11 @@ export type UseReconnectReturnType<context = unknown> = Compute<
     context
   > & {
     connectors: readonly Connector[]
+    mutate: ReconnectMutate<context>
+    mutateAsync: ReconnectMutateAsync<context>
+    /** @deprecated use `mutate` instead */
     reconnect: ReconnectMutate<context>
+    /** @deprecated use `mutateAsync` instead */
     reconnectAsync: ReconnectMutateAsync<context>
   }
 >
@@ -48,20 +52,13 @@ export type UseReconnectReturnType<context = unknown> = Compute<
 export function useReconnect<context = unknown>(
   parameters: UseReconnectParameters<context> = {},
 ): UseReconnectReturnType<context> {
-  const { mutation } = parameters
-
   const config = useConfig(parameters)
-
   const mutationOptions = reconnectMutationOptions(config)
-  const { mutate, mutateAsync, ...result } = useMutation({
-    ...mutation,
-    ...mutationOptions,
-  })
-
+  const mutation = useMutation({ ...parameters.mutation, ...mutationOptions })
   return {
-    ...result,
+    ...mutation,
     connectors: config.connectors,
-    reconnect: mutate,
-    reconnectAsync: mutateAsync,
+    reconnect: mutation.mutate,
+    reconnectAsync: mutation.mutateAsync,
   }
 }

package/src/hooks/useSendCalls.ts

@@ -44,7 +44,11 @@ export type UseSendCallsReturnType<
     SendCallsVariables<config, config['chains'][number]['id']>,
     context
   > & {
+    mutate: SendCallsMutate<config, context>
+    mutateAsync: SendCallsMutateAsync<config, context>
+    /** @deprecated use `mutate` instead */
     sendCalls: SendCallsMutate<config, context>
+    /** @deprecated use `mutateAsync` instead */
     sendCallsAsync: SendCallsMutateAsync<config, context>
   }
 >
@@ -56,20 +60,15 @@ export function useSendCalls<
 >(
   parameters: UseSendCallsParameters<config, context> = {},
 ): UseSendCallsReturnType<config, context> {
-  const { mutation } = parameters
-
   const config = useConfig(parameters)
-
   const mutationOptions = sendCallsMutationOptions(config)
-  const { mutate, mutateAsync, ...result } = useMutation({
-    ...mutation,
-    ...mutationOptions,
-  })
-
+  const mutation = useMutation({ ...parameters.mutation, ...mutationOptions })
   type Return = UseSendCallsReturnType<config, context>
   return {
-    ...result,
-    sendCalls: mutate as Return['sendCalls'],
-    sendCallsAsync: mutateAsync as Return['sendCallsAsync'],
+    ...mutation,
+    mutate: mutation.mutate as Return['mutate'],
+    mutateAsync: mutation.mutateAsync as Return['mutateAsync'],
+    sendCalls: mutation.mutate as Return['mutate'],
+    sendCallsAsync: mutation.mutateAsync as Return['mutateAsync'],
   }
 }

package/src/hooks/useSendCallsSync.ts

@@ -48,7 +48,11 @@ export type UseSendCallsSyncReturnType<
     SendCallsSyncVariables<config, config['chains'][number]['id']>,
     context
   > & {
+    mutate: SendCallsSyncMutate<config, context>
+    mutateAsync: SendCallsSyncMutateAsync<config, context>
+    /** @deprecated use `mutate` instead */
     sendCallsSync: SendCallsSyncMutate<config, context>
+    /** @deprecated use `mutateAsync` instead */
     sendCallsSyncAsync: SendCallsSyncMutateAsync<config, context>
   }
 >
@@ -60,20 +64,15 @@ export function useSendCallsSync<
 >(
   parameters: UseSendCallsSyncParameters<config, context> = {},
 ): UseSendCallsSyncReturnType<config, context> {
-  const { mutation } = parameters
-
   const config = useConfig(parameters)
-
   const mutationOptions = sendCallsSyncMutationOptions(config)
-  const { mutate, mutateAsync, ...result } = useMutation({
-    ...mutation,
-    ...mutationOptions,
-  })
-
+  const mutation = useMutation({ ...parameters.mutation, ...mutationOptions })
   type Return = UseSendCallsSyncReturnType<config, context>
   return {
-    ...result,
-    sendCallsSync: mutate as Return['sendCallsSync'],
-    sendCallsSyncAsync: mutateAsync as Return['sendCallsSyncAsync'],
+    ...mutation,
+    mutate: mutation.mutate as Return['mutate'],
+    mutateAsync: mutation.mutateAsync as Return['mutateAsync'],
+    sendCallsSync: mutation.mutate as Return['mutate'],
+    sendCallsSyncAsync: mutation.mutateAsync as Return['mutateAsync'],
   }
 }

package/src/hooks/useSendTransaction.ts

@@ -48,7 +48,11 @@ export type UseSendTransactionReturnType<
     SendTransactionVariables<config, config['chains'][number]['id']>,
     context
   > & {
+    mutate: SendTransactionMutate<config, context>
+    mutateAsync: SendTransactionMutateAsync<config, context>
+    /** @deprecated use `mutate` instead */
     sendTransaction: SendTransactionMutate<config, context>
+    /** @deprecated use `mutateAsync` instead */
     sendTransactionAsync: SendTransactionMutateAsync<config, context>
   }
 >
@@ -60,20 +64,13 @@ export function useSendTransaction<
 >(
   parameters: UseSendTransactionParameters<config, context> = {},
 ): UseSendTransactionReturnType<config, context> {
-  const { mutation } = parameters
-
   const config = useConfig(parameters)
-
   const mutationOptions = sendTransactionMutationOptions(config)
-  const { mutate, mutateAsync, ...result } = useMutation({
-    ...mutation,
-    ...mutationOptions,
-  })
-
+  const mutation = useMutation({ ...parameters.mutation, ...mutationOptions })
   type Return = UseSendTransactionReturnType<config, context>
   return {
-    ...result,
-    sendTransaction: mutate as Return['sendTransaction'],
-    sendTransactionAsync: mutateAsync as Return['sendTransactionAsync'],
+    ...mutation,
+    sendTransaction: mutation.mutate as Return['mutate'],
+    sendTransactionAsync: mutation.mutateAsync as Return['mutateAsync'],
   }
 }

package/src/hooks/useSendTransactionSync.ts

@@ -48,7 +48,11 @@ export type UseSendTransactionSyncReturnType<
     SendTransactionSyncVariables<config, config['chains'][number]['id']>,
     context
   > & {
+    mutate: SendTransactionSyncMutate<config, context>
+    mutateAsync: SendTransactionSyncMutateAsync<config, context>
+    /** @deprecated use `mutate` instead */
     sendTransactionSync: SendTransactionSyncMutate<config, context>
+    /** @deprecated use `mutateAsync` instead */
     sendTransactionSyncAsync: SendTransactionSyncMutateAsync<config, context>
   }
 >
@@ -60,20 +64,13 @@ export function useSendTransactionSync<
 >(
   parameters: UseSendTransactionSyncParameters<config, context> = {},
 ): UseSendTransactionSyncReturnType<config, context> {
-  const { mutation } = parameters
-
   const config = useConfig(parameters)
-
   const mutationOptions = sendTransactionSyncMutationOptions(config)
-  const { mutate, mutateAsync, ...result } = useMutation({
-    ...mutation,
-    ...mutationOptions,
-  })
-
+  const mutation = useMutation({ ...parameters.mutation, ...mutationOptions })
   type Return = UseSendTransactionSyncReturnType<config, context>
   return {
-    ...result,
-    sendTransactionSync: mutate as Return['sendTransactionSync'],
-    sendTransactionSyncAsync: mutateAsync as Return['sendTransactionSyncAsync'],
+    ...mutation,
+    sendTransactionSync: mutation.mutate as Return['mutate'],
+    sendTransactionSyncAsync: mutation.mutateAsync as Return['mutateAsync'],
   }
 }

package/src/hooks/useShowCallsStatus.ts

@@ -45,7 +45,11 @@ export type UseShowCallsStatusReturnType<context = unknown> = Compute<
     ShowCallsStatusVariables,
     context
   > & {
+    mutate: ShowCallsStatusMutate
+    mutateAsync: ShowCallsStatusMutateAsync
+    /** @deprecated use `mutate` instead */
     showCallsStatus: ShowCallsStatusMutate
+    /** @deprecated use `mutateAsync` instead */
     showCallsStatusAsync: ShowCallsStatusMutateAsync
   }
 >
@@ -57,20 +61,13 @@ export function useShowCallsStatus<
 >(
   parameters: UseShowCallsStatusParameters<config, context> = {},
 ): UseShowCallsStatusReturnType<context> {
-  const { mutation } = parameters
-
   const config = useConfig(parameters)
-
   const mutationOptions = showCallsStatusMutationOptions(config)
-  const { mutate, mutateAsync, ...result } = useMutation({
-    ...mutation,
-    ...mutationOptions,
-  })
-
-  type Return = UseShowCallsStatusReturnType
+  const mutation = useMutation({ ...parameters.mutation, ...mutationOptions })
+  type Return = UseShowCallsStatusReturnType<context>
   return {
-    ...result,
-    showCallsStatus: mutate as Return['showCallsStatus'],
-    showCallsStatusAsync: mutateAsync as Return['showCallsStatusAsync'],
+    ...mutation,
+    showCallsStatus: mutation.mutate as Return['mutate'],
+    showCallsStatusAsync: mutation.mutateAsync as Return['mutateAsync'],
   }
 }

package/src/hooks/useSignMessage.ts

@@ -38,7 +38,11 @@ export type UseSignMessageReturnType<context = unknown> = Compute<
     SignMessageVariables,
     context
   > & {
+    mutate: SignMessageMutate<context>
+    mutateAsync: SignMessageMutateAsync<context>
+    /** @deprecated use `mutate` instead */
     signMessage: SignMessageMutate<context>
+    /** @deprecated use `mutateAsync` instead */
     signMessageAsync: SignMessageMutateAsync<context>
   }
 >
@@ -47,19 +51,12 @@ export type UseSignMessageReturnType<context = unknown> = Compute<
 export function useSignMessage<context = unknown>(
   parameters: UseSignMessageParameters<context> = {},
 ): UseSignMessageReturnType<context> {
-  const { mutation } = parameters
-
   const config = useConfig(parameters)
-
   const mutationOptions = signMessageMutationOptions(config)
-  const { mutate, mutateAsync, ...result } = useMutation({
-    ...mutation,
-    ...mutationOptions,
-  })
-
+  const mutation = useMutation({ ...parameters.mutation, ...mutationOptions })
   return {
-    ...result,
-    signMessage: mutate,
-    signMessageAsync: mutateAsync,
+    ...mutation,
+    signMessage: mutation.mutate,
+    signMessageAsync: mutation.mutateAsync,
   }
 }

package/src/hooks/useSignTypedData.ts

@@ -38,7 +38,11 @@ export type UseSignTypedDataReturnType<context = unknown> = Compute<
     SignTypedDataVariables,
     context
   > & {
+    mutate: SignTypedDataMutate<context>
+    mutateAsync: SignTypedDataMutateAsync<context>
+    /** @deprecated use `mutate` instead */
     signTypedData: SignTypedDataMutate<context>
+    /** @deprecated use `mutateAsync` instead */
     signTypedDataAsync: SignTypedDataMutateAsync<context>
   }
 >
@@ -47,20 +51,15 @@ export type UseSignTypedDataReturnType<context = unknown> = Compute<
 export function useSignTypedData<context = unknown>(
   parameters: UseSignTypedDataParameters<context> = {},
 ): UseSignTypedDataReturnType<context> {
-  const { mutation } = parameters
-
   const config = useConfig(parameters)
-
   const mutationOptions = signTypedDataMutationOptions(config)
-  const { mutate, mutateAsync, ...result } = useMutation({
-    ...mutation,
-    ...mutationOptions,
-  })
-
+  const mutation = useMutation({ ...parameters.mutation, ...mutationOptions })
   type Return = UseSignTypedDataReturnType<context>
   return {
-    ...result,
-    signTypedData: mutate as Return['signTypedData'],
-    signTypedDataAsync: mutateAsync as Return['signTypedDataAsync'],
+    ...mutation,
+    mutate: mutation.mutate as Return['mutate'],
+    mutateAsync: mutation.mutateAsync as Return['mutateAsync'],
+    signTypedData: mutation.mutate as Return['mutate'],
+    signTypedDataAsync: mutation.mutateAsync as Return['mutateAsync'],
   }
 }