@wagmi/core 3.2.3 → 3.3.1

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>
 

package/src/query/writeContractSync.ts

@@ -0,0 +1,130 @@
+import type { MutateOptions, MutationOptions } from '@tanstack/query-core'
+import type { Abi, ContractFunctionArgs, ContractFunctionName } from 'viem'
+import {
+  type WriteContractSyncErrorType,
+  type WriteContractSyncParameters,
+  type WriteContractSyncReturnType,
+  writeContractSync,
+} from '../actions/writeContractSync.js'
+import type { Config } from '../createConfig.js'
+import type { MutationParameter } from '../types/query.js'
+import type { Compute } from '../types/utils.js'
+
+export type WriteContractSyncOptions<
+  config extends Config,
+  context = unknown,
+> = MutationParameter<
+  WriteContractSyncData,
+  WriteContractSyncErrorType,
+  WriteContractSyncVariables<
+    Abi,
+    string,
+    readonly unknown[],
+    config,
+    config['chains'][number]['id']
+  >,
+  context
+>
+
+export function writeContractSyncMutationOptions<
+  config extends Config,
+  context,
+>(
+  config: config,
+  options: WriteContractSyncOptions<config, context> = {},
+): WriteContractSyncMutationOptions<config> {
+  return {
+    ...(options.mutation as any),
+    mutationFn(variables) {
+      return writeContractSync(config, variables)
+    },
+    mutationKey: ['writeContractSync'],
+  }
+}
+
+export type WriteContractSyncMutationOptions<config extends Config> =
+  MutationOptions<
+    WriteContractSyncData,
+    WriteContractSyncErrorType,
+    WriteContractSyncVariables<
+      Abi,
+      string,
+      readonly unknown[],
+      config,
+      config['chains'][number]['id']
+    >
+  >
+
+export type WriteContractSyncData = Compute<WriteContractSyncReturnType>
+
+export type WriteContractSyncVariables<
+  abi extends Abi | readonly unknown[],
+  functionName extends ContractFunctionName<abi, 'nonpayable' | 'payable'>,
+  args extends ContractFunctionArgs<
+    abi,
+    'nonpayable' | 'payable',
+    functionName
+  >,
+  config extends Config,
+  chainId extends config['chains'][number]['id'],
+> = WriteContractSyncParameters<abi, functionName, args, config, chainId>
+
+export type WriteContractSyncMutate<
+  config extends Config,
+  context = unknown,
+> = <
+  const abi extends Abi | readonly unknown[],
+  functionName extends ContractFunctionName<abi, 'nonpayable' | 'payable'>,
+  args extends ContractFunctionArgs<
+    abi,
+    'nonpayable' | 'payable',
+    functionName
+  >,
+  chainId extends config['chains'][number]['id'],
+>(
+  variables: WriteContractSyncVariables<
+    abi,
+    functionName,
+    args,
+    config,
+    chainId
+  >,
+  options?:
+    | MutateOptions<
+        WriteContractSyncData,
+        WriteContractSyncErrorType,
+        WriteContractSyncVariables<abi, functionName, args, config, chainId>,
+        context
+      >
+    | undefined,
+) => void
+
+export type WriteContractSyncMutateAsync<
+  config extends Config,
+  context = unknown,
+> = <
+  const abi extends Abi | readonly unknown[],
+  functionName extends ContractFunctionName<abi, 'nonpayable' | 'payable'>,
+  args extends ContractFunctionArgs<
+    abi,
+    'nonpayable' | 'payable',
+    functionName
+  >,
+  chainId extends config['chains'][number]['id'],
+>(
+  variables: WriteContractSyncVariables<
+    abi,
+    functionName,
+    args,
+    config,
+    chainId
+  >,
+  options?:
+    | MutateOptions<
+        WriteContractSyncData,
+        WriteContractSyncErrorType,
+        WriteContractSyncVariables<abi, functionName, args, config, chainId>,
+        context
+      >
+    | undefined,
+) => Promise<WriteContractSyncData>

package/src/tempo/Connectors.ts

@@ -91,7 +91,9 @@ export function webAuthn(options: webAuthn.Parameters) {
         'webAuthn.activeCredential',
       )
       if (!credential) return
-      account = Account.fromWebAuthnP256(credential)
+      account = Account.fromWebAuthnP256(credential, {
+        rpId: options.getOptions?.rpId ?? options.rpId,
+      })
     },
     async connect(parameters = {}) {
       const capabilities =
@@ -243,7 +245,9 @@ export function webAuthn(options: webAuthn.Parameters) {
         normalizeValue(credential),
       )
 
-      account = Account.fromWebAuthnP256(credential)
+      account = Account.fromWebAuthnP256(credential, {
+        rpId: options.getOptions?.rpId ?? options.rpId,
+      })
 
       if (keyPair) {
         accessKey = Account.fromWebCryptoP256(keyPair, {

package/src/tempo/KeyManager.ts

@@ -200,22 +200,24 @@ function serializeCredential(
       ...('getAuthenticatorData' in response &&
         typeof response.getAuthenticatorData === 'function' && {
           authenticatorData: Base64.fromBytes(
-            new Uint8Array(response.getAuthenticatorData() as ArrayBuffer),
+            new Uint8Array(
+              response.getAuthenticatorData.call(response) as ArrayBuffer,
+            ),
           ),
         }),
       ...('getPublicKey' in response &&
         typeof response.getPublicKey === 'function' && {
           publicKey: Base64.fromBytes(
-            new Uint8Array(response.getPublicKey() as ArrayBuffer),
+            new Uint8Array(response.getPublicKey.call(response) as ArrayBuffer),
           ),
         }),
       ...('getPublicKeyAlgorithm' in response &&
         typeof response.getPublicKeyAlgorithm === 'function' && {
-          publicKeyAlgorithm: response.getPublicKeyAlgorithm(),
+          publicKeyAlgorithm: response.getPublicKeyAlgorithm.call(response),
         }),
       ...('getTransports' in response &&
         typeof response.getTransports === 'function' && {
-          transports: response.getTransports(),
+          transports: response.getTransports.call(response),
         }),
       ...('authenticatorData' in response && {
         authenticatorData: Base64.fromBytes(

package/src/types/query.ts

@@ -1,5 +1,19 @@
 import type * as Query from '@tanstack/query-core'
-import type { RequiredBy, UnionLooseOmit } from './utils.js'
+import type { Compute, LooseOmit, RequiredBy, UnionLooseOmit } from './utils.js'
+
+export type MutationParameter<
+  data = unknown,
+  error = Error,
+  variables = void,
+  context = unknown,
+> = {
+  mutation?:
+    | LooseOmit<
+        Query.MutationOptions<data, error, Compute<variables>, context>,
+        'mutationFn' | 'mutationKey' | 'throwOnError'
+      >
+    | undefined
+}
 
 export type QueryParameter<
   queryFnData = unknown,

package/src/version.ts

@@ -1 +1 @@
-export const version = '3.2.3'
+export const version = '3.3.1'