@wagmi/core 3.2.2 → 3.3.0

package/src/query/sendCalls.ts

@@ -1,5 +1,4 @@
 import type { MutateOptions, MutationOptions } from '@tanstack/query-core'
-
 import {
   type SendCallsErrorType,
   type SendCallsParameters,
@@ -7,23 +6,38 @@ import {
   sendCalls,
 } from '../actions/sendCalls.js'
 import type { Config } from '../createConfig.js'
+import type { MutationParameter } from '../types/query.js'
 import type { Compute } from '../types/utils.js'
 
-export function sendCallsMutationOptions<config extends Config>(
+export type SendCallsOptions<
+  config extends Config,
+  context = unknown,
+> = MutationParameter<
+  SendCallsData,
+  SendCallsErrorType,
+  SendCallsVariables<config, config['chains'][number]['id']>,
+  context
+>
+
+export function sendCallsMutationOptions<config extends Config, context>(
   config: config,
-) {
+  options: SendCallsOptions<config, context> = {},
+): SendCallsMutationOptions<config> {
   return {
+    ...(options.mutation as any),
     mutationFn(variables) {
       return sendCalls(config, variables)
     },
     mutationKey: ['sendCalls'],
-  } as const satisfies MutationOptions<
-    SendCallsData,
-    SendCallsErrorType,
-    SendCallsVariables<config, config['chains'][number]['id']>
-  >
+  }
 }
 
+export type SendCallsMutationOptions<config extends Config> = MutationOptions<
+  SendCallsData,
+  SendCallsErrorType,
+  SendCallsVariables<config, config['chains'][number]['id']>
+>
+
 export type SendCallsData = Compute<SendCallsReturnType>
 
 export type SendCallsVariables<

package/src/query/sendCallsSync.ts

@@ -1,5 +1,4 @@
 import type { MutateOptions, MutationOptions } from '@tanstack/query-core'
-
 import {
   type SendCallsSyncErrorType,
   type SendCallsSyncParameters,
@@ -7,22 +6,38 @@ import {
   sendCallsSync,
 } from '../actions/sendCallsSync.js'
 import type { Config } from '../createConfig.js'
+import type { MutationParameter } from '../types/query.js'
 import type { Compute } from '../types/utils.js'
 
-export function sendCallsSyncMutationOptions<config extends Config>(
+export type SendCallsSyncOptions<
+  config extends Config,
+  context = unknown,
+> = MutationParameter<
+  SendCallsSyncData,
+  SendCallsSyncErrorType,
+  SendCallsSyncVariables<config, config['chains'][number]['id']>,
+  context
+>
+
+export function sendCallsSyncMutationOptions<config extends Config, context>(
   config: config,
-) {
+  options: SendCallsSyncOptions<config, context> = {},
+): SendCallsSyncMutationOptions<config> {
   return {
+    ...(options.mutation as any),
     mutationFn(variables) {
       return sendCallsSync(config, variables)
     },
     mutationKey: ['sendCallsSync'],
-  } as const satisfies MutationOptions<
+  }
+}
+
+export type SendCallsSyncMutationOptions<config extends Config> =
+  MutationOptions<
     SendCallsSyncData,
     SendCallsSyncErrorType,
     SendCallsSyncVariables<config, config['chains'][number]['id']>
   >
-}
 
 export type SendCallsSyncData = Compute<SendCallsSyncReturnType>
 

package/src/query/sendTransaction.ts

@@ -1,5 +1,4 @@
 import type { MutateOptions, MutationOptions } from '@tanstack/query-core'
-
 import {
   type SendTransactionErrorType,
   type SendTransactionParameters,
@@ -7,22 +6,38 @@ import {
   sendTransaction,
 } from '../actions/sendTransaction.js'
 import type { Config } from '../createConfig.js'
+import type { MutationParameter } from '../types/query.js'
 import type { Compute } from '../types/utils.js'
 
-export function sendTransactionMutationOptions<config extends Config>(
+export type SendTransactionOptions<
+  config extends Config,
+  context = unknown,
+> = MutationParameter<
+  SendTransactionData,
+  SendTransactionErrorType,
+  SendTransactionVariables<config, config['chains'][number]['id']>,
+  context
+>
+
+export function sendTransactionMutationOptions<config extends Config, context>(
   config: config,
-) {
+  options: SendTransactionOptions<config, context> = {},
+): SendTransactionMutationOptions<config> {
   return {
+    ...(options.mutation as any),
     mutationFn(variables) {
       return sendTransaction(config, variables)
     },
     mutationKey: ['sendTransaction'],
-  } as const satisfies MutationOptions<
+  }
+}
+
+export type SendTransactionMutationOptions<config extends Config> =
+  MutationOptions<
     SendTransactionData,
     SendTransactionErrorType,
     SendTransactionVariables<config, config['chains'][number]['id']>
   >
-}
 
 export type SendTransactionData = Compute<SendTransactionReturnType>
 

package/src/query/sendTransactionSync.ts

@@ -1,5 +1,4 @@
 import type { MutateOptions, MutationOptions } from '@tanstack/query-core'
-
 import {
   type SendTransactionSyncErrorType,
   type SendTransactionSyncParameters,
@@ -7,22 +6,41 @@ import {
   sendTransactionSync,
 } from '../actions/sendTransactionSync.js'
 import type { Config } from '../createConfig.js'
+import type { MutationParameter } from '../types/query.js'
 import type { Compute } from '../types/utils.js'
 
-export function sendTransactionSyncMutationOptions<config extends Config>(
+export type SendTransactionSyncOptions<
+  config extends Config,
+  context = unknown,
+> = MutationParameter<
+  SendTransactionSyncData,
+  SendTransactionSyncErrorType,
+  SendTransactionSyncVariables<config, config['chains'][number]['id']>,
+  context
+>
+
+export function sendTransactionSyncMutationOptions<
+  config extends Config,
+  context,
+>(
   config: config,
-) {
+  options: SendTransactionSyncOptions<config, context> = {},
+): SendTransactionSyncMutationOptions<config> {
   return {
+    ...(options.mutation as any),
     mutationFn(variables) {
       return sendTransactionSync(config, variables)
     },
     mutationKey: ['sendTransactionSync'],
-  } as const satisfies MutationOptions<
+  }
+}
+
+export type SendTransactionSyncMutationOptions<config extends Config> =
+  MutationOptions<
     SendTransactionSyncData,
     SendTransactionSyncErrorType,
     SendTransactionSyncVariables<config, config['chains'][number]['id']>
   >
-}
 
 export type SendTransactionSyncData = Compute<SendTransactionSyncReturnType>
 

package/src/query/showCallsStatus.ts

@@ -1,5 +1,4 @@
 import type { MutateOptions, MutationOptions } from '@tanstack/query-core'
-
 import {
   type ShowCallsStatusErrorType,
   type ShowCallsStatusParameters,
@@ -7,23 +6,35 @@ import {
   showCallsStatus,
 } from '../actions/showCallsStatus.js'
 import type { Config } from '../createConfig.js'
+import type { MutationParameter } from '../types/query.js'
 import type { Compute } from '../types/utils.js'
 
-export function showCallsStatusMutationOptions<config extends Config>(
+export type ShowCallsStatusOptions<context = unknown> = MutationParameter<
+  ShowCallsStatusData,
+  ShowCallsStatusErrorType,
+  ShowCallsStatusVariables,
+  context
+>
+
+export function showCallsStatusMutationOptions<config extends Config, context>(
   config: config,
-) {
+  options: ShowCallsStatusOptions<context> = {},
+): ShowCallsStatusMutationOptions {
   return {
+    ...(options.mutation as any),
     mutationFn(variables) {
       return showCallsStatus(config, variables)
     },
     mutationKey: ['showCallsStatus'],
-  } as const satisfies MutationOptions<
-    ShowCallsStatusData,
-    ShowCallsStatusErrorType,
-    ShowCallsStatusVariables
-  >
+  }
 }
 
+export type ShowCallsStatusMutationOptions = MutationOptions<
+  ShowCallsStatusData,
+  ShowCallsStatusErrorType,
+  ShowCallsStatusVariables
+>
+
 export type ShowCallsStatusData = Compute<ShowCallsStatusReturnType>
 
 export type ShowCallsStatusVariables = ShowCallsStatusParameters

package/src/query/signMessage.ts

@@ -1,5 +1,4 @@
 import type { MutationOptions } from '@tanstack/query-core'
-
 import {
   type SignMessageErrorType,
   type SignMessageParameters,
@@ -7,22 +6,36 @@ import {
   signMessage,
 } from '../actions/signMessage.js'
 import type { Config } from '../createConfig.js'
+import type { MutationParameter } from '../types/query.js'
 import type { Compute } from '../types/utils.js'
 import type { Mutate, MutateAsync } from './types.js'
 
-export function signMessageMutationOptions(config: Config) {
+export type SignMessageOptions<context = unknown> = MutationParameter<
+  SignMessageData,
+  SignMessageErrorType,
+  SignMessageVariables,
+  context
+>
+
+export function signMessageMutationOptions<context>(
+  config: Config,
+  options: SignMessageOptions<context> = {},
+): SignMessageMutationOptions {
   return {
+    ...(options.mutation as any),
     mutationFn(variables) {
       return signMessage(config, variables)
     },
     mutationKey: ['signMessage'],
-  } as const satisfies MutationOptions<
-    SignMessageData,
-    SignMessageErrorType,
-    SignMessageVariables
-  >
+  }
 }
 
+export type SignMessageMutationOptions = MutationOptions<
+  SignMessageData,
+  SignMessageErrorType,
+  SignMessageVariables
+>
+
 export type SignMessageData = SignMessageReturnType
 
 export type SignMessageVariables = Compute<SignMessageParameters>

package/src/query/signTypedData.ts

@@ -1,5 +1,4 @@
 import type { MutateOptions, MutationOptions } from '@tanstack/query-core'
-
 import type { TypedData } from 'viem'
 import {
   type SignTypedDataErrorType,
@@ -8,23 +7,35 @@ import {
   signTypedData,
 } from '../actions/signTypedData.js'
 import type { Config } from '../createConfig.js'
+import type { MutationParameter } from '../types/query.js'
 import type { Compute } from '../types/utils.js'
 
-export function signTypedDataMutationOptions<config extends Config>(
+export type SignTypedDataOptions<context = unknown> = MutationParameter<
+  SignTypedDataData,
+  SignTypedDataErrorType,
+  SignTypedDataVariables,
+  context
+>
+
+export function signTypedDataMutationOptions<config extends Config, context>(
   config: config,
-) {
+  options: SignTypedDataOptions<context> = {},
+): SignTypedDataMutationOptions {
   return {
+    ...(options.mutation as any),
     mutationFn(variables) {
       return signTypedData(config, variables)
     },
     mutationKey: ['signTypedData'],
-  } as const satisfies MutationOptions<
-    SignTypedDataData,
-    SignTypedDataErrorType,
-    SignTypedDataVariables
-  >
+  }
 }
 
+export type SignTypedDataMutationOptions = MutationOptions<
+  SignTypedDataData,
+  SignTypedDataErrorType,
+  SignTypedDataVariables
+>
+
 export type SignTypedDataData = Compute<SignTypedDataReturnType>
 
 export type SignTypedDataVariables<

package/src/query/switchChain.ts

@@ -1,5 +1,4 @@
 import type { MutateOptions, MutationOptions } from '@tanstack/query-core'
-
 import {
   type SwitchChainErrorType,
   type SwitchChainParameters,
@@ -7,23 +6,38 @@ import {
   switchChain,
 } from '../actions/switchChain.js'
 import type { Config } from '../createConfig.js'
+import type { MutationParameter } from '../types/query.js'
 import type { Compute } from '../types/utils.js'
 
-export function switchChainMutationOptions<config extends Config>(
+export type SwitchChainOptions<
+  config extends Config,
+  context = unknown,
+> = MutationParameter<
+  SwitchChainData<config, config['chains'][number]['id']>,
+  SwitchChainErrorType,
+  SwitchChainVariables<config, config['chains'][number]['id']>,
+  context
+>
+
+export function switchChainMutationOptions<config extends Config, context>(
   config: config,
-) {
+  options: SwitchChainOptions<config, context> = {},
+): SwitchChainMutationOptions<config> {
   return {
+    ...(options.mutation as any),
     mutationFn(variables) {
       return switchChain(config, variables)
     },
     mutationKey: ['switchChain'],
-  } as const satisfies MutationOptions<
-    SwitchChainData<config, config['chains'][number]['id']>,
-    SwitchChainErrorType,
-    SwitchChainVariables<config, config['chains'][number]['id']>
-  >
+  }
 }
 
+export type SwitchChainMutationOptions<config extends Config> = MutationOptions<
+  SwitchChainData<config, config['chains'][number]['id']>,
+  SwitchChainErrorType,
+  SwitchChainVariables<config, config['chains'][number]['id']>
+>
+
 export type SwitchChainData<
   config extends Config,
   chainId extends config['chains'][number]['id'],

package/src/query/switchConnection.ts

@@ -1,5 +1,4 @@
 import type { MutationOptions } from '@tanstack/query-core'
-
 import {
   type SwitchConnectionErrorType,
   type SwitchConnectionParameters,
@@ -7,23 +6,39 @@ import {
   switchConnection,
 } from '../actions/switchConnection.js'
 import type { Config } from '../createConfig.js'
+import type { MutationParameter } from '../types/query.js'
 import type { Compute } from '../types/utils.js'
 import type { Mutate, MutateAsync } from './types.js'
 
-export function switchConnectionMutationOptions<config extends Config>(
+export type SwitchConnectionOptions<
+  config extends Config,
+  context = unknown,
+> = MutationParameter<
+  SwitchConnectionData<config>,
+  SwitchConnectionErrorType,
+  SwitchConnectionVariables,
+  context
+>
+
+export function switchConnectionMutationOptions<config extends Config, context>(
   config: config,
-) {
+  options: SwitchConnectionOptions<config, context> = {},
+): SwitchConnectionMutationOptions<config> {
   return {
+    ...(options.mutation as any),
     mutationFn(variables) {
       return switchConnection(config, variables)
     },
     mutationKey: ['switchConnection'],
-  } as const satisfies MutationOptions<
+  }
+}
+
+export type SwitchConnectionMutationOptions<config extends Config> =
+  MutationOptions<
     SwitchConnectionData<config>,
     SwitchConnectionErrorType,
     SwitchConnectionVariables
   >
-}
 
 export type SwitchConnectionData<config extends Config> = Compute<
   SwitchConnectionReturnType<config>

package/src/query/verifyTypedData.ts

@@ -1,5 +1,4 @@
 import type { TypedData } from 'viem'
-
 import {
   type VerifyTypedDataErrorType,
   type VerifyTypedDataParameters,

package/src/query/watchAsset.ts

@@ -1,5 +1,4 @@
 import type { MutationOptions } from '@tanstack/query-core'
-
 import {
   type WatchAssetErrorType,
   type WatchAssetParameters,
@@ -7,22 +6,36 @@ import {
   watchAsset,
 } from '../actions/watchAsset.js'
 import type { Config } from '../createConfig.js'
+import type { MutationParameter } from '../types/query.js'
 import type { Compute } from '../types/utils.js'
 import type { Mutate, MutateAsync } from './types.js'
 
-export function watchAssetMutationOptions(config: Config) {
+export type WatchAssetOptions<context = unknown> = MutationParameter<
+  WatchAssetData,
+  WatchAssetErrorType,
+  WatchAssetVariables,
+  context
+>
+
+export function watchAssetMutationOptions<context>(
+  config: Config,
+  options: WatchAssetOptions<context> = {},
+): WatchAssetMutationOptions {
   return {
+    ...(options.mutation as any),
     mutationFn(variables) {
       return watchAsset(config, variables)
     },
     mutationKey: ['watchAsset'],
-  } as const satisfies MutationOptions<
-    WatchAssetData,
-    WatchAssetErrorType,
-    WatchAssetVariables
-  >
+  }
 }
 
+export type WatchAssetMutationOptions = MutationOptions<
+  WatchAssetData,
+  WatchAssetErrorType,
+  WatchAssetVariables
+>
+
 export type WatchAssetData = WatchAssetReturnType
 
 export type WatchAssetVariables = Compute<WatchAssetParameters>

package/src/query/writeContract.ts

@@ -1,6 +1,5 @@
 import type { MutateOptions, MutationOptions } from '@tanstack/query-core'
 import type { Abi, ContractFunctionArgs, ContractFunctionName } from 'viem'
-
 import {
   type WriteContractErrorType,
   type WriteContractParameters,
@@ -8,17 +7,40 @@ import {
   writeContract,
 } from '../actions/writeContract.js'
 import type { Config } from '../createConfig.js'
+import type { MutationParameter } from '../types/query.js'
 import type { Compute } from '../types/utils.js'
 
-export function writeContractMutationOptions<config extends Config>(
+export type WriteContractOptions<
+  config extends Config,
+  context = unknown,
+> = MutationParameter<
+  WriteContractData,
+  WriteContractErrorType,
+  WriteContractVariables<
+    Abi,
+    string,
+    readonly unknown[],
+    config,
+    config['chains'][number]['id']
+  >,
+  context
+>
+
+export function writeContractMutationOptions<config extends Config, context>(
   config: config,
-) {
+  options: WriteContractOptions<config, context> = {},
+): WriteContractMutationOptions<config> {
   return {
+    ...(options.mutation as any),
     mutationFn(variables) {
       return writeContract(config, variables)
     },
     mutationKey: ['writeContract'],
-  } as const satisfies MutationOptions<
+  }
+}
+
+export type WriteContractMutationOptions<config extends Config> =
+  MutationOptions<
     WriteContractData,
     WriteContractErrorType,
     WriteContractVariables<
@@ -29,7 +51,6 @@ export function writeContractMutationOptions<config extends Config>(
       config['chains'][number]['id']
     >
   >
-}
 
 export type WriteContractData = Compute<WriteContractReturnType>