@wagmi/core 3.2.1 → 3.2.3

package/src/query/readContracts.ts

@@ -1,9 +1,7 @@
-import type { QueryOptions } from '@tanstack/query-core'
 import type {
   ContractFunctionParameters,
   MulticallParameters as viem_MulticallParameters,
 } from 'viem'
-
 import {
   type ReadContractsErrorType,
   type ReadContractsReturnType,
@@ -14,6 +12,7 @@ import type {
   ChainIdParameter,
   ScopeKeyParameter,
 } from '../types/properties.js'
+import type { QueryOptions, QueryParameter } from '../types/query.js'
 import type { ExactPartial } from '../types/utils.js'
 import { filterQueryOptions } from './utils.js'
 
@@ -21,6 +20,7 @@ export type ReadContractsOptions<
   contracts extends readonly unknown[],
   allowFailure extends boolean,
   config extends Config,
+  selectData = ReadContractsData<contracts, allowFailure>,
 > = ExactPartial<
   viem_MulticallParameters<
     contracts,
@@ -28,39 +28,42 @@ export type ReadContractsOptions<
     { optional: true; properties: ChainIdParameter<config> }
   >
 > &
-  ScopeKeyParameter
+  ScopeKeyParameter &
+  QueryParameter<
+    ReadContractsQueryFnData<contracts, allowFailure>,
+    ReadContractsErrorType,
+    selectData,
+    ReadContractsQueryKey<contracts, allowFailure, config>
+  >
 
 export function readContractsQueryOptions<
   config extends Config,
   const contracts extends readonly unknown[],
   allowFailure extends boolean = true,
+  selectData = ReadContractsData<contracts, allowFailure>,
 >(
   config: config,
-  options: ReadContractsOptions<contracts, allowFailure, config> &
+  options: ReadContractsOptions<contracts, allowFailure, config, selectData> &
     ChainIdParameter<config> = {},
-) {
+): ReadContractsQueryOptions<contracts, allowFailure, config, selectData> {
   return {
-    async queryFn({ queryKey }) {
+    ...options.query,
+    queryFn: async (context) => {
       const contracts: ContractFunctionParameters[] = []
-      const length = queryKey[1].contracts.length
+      const length = context.queryKey[1].contracts.length
       for (let i = 0; i < length; i++) {
-        const contract = queryKey[1].contracts[i]!
+        const contract = context.queryKey[1].contracts[i]!
         const abi = (options.contracts?.[i] as ContractFunctionParameters).abi
         contracts.push({ ...contract, abi })
       }
-      const { scopeKey: _, ...parameters } = queryKey[1]
+      const { scopeKey: _, ...parameters } = context.queryKey[1]
       return readContracts(config, {
         ...parameters,
         contracts,
       }) as Promise<ReadContractsReturnType<contracts, allowFailure>>
     },
     queryKey: readContractsQueryKey(options),
-  } as const satisfies QueryOptions<
-    ReadContractsQueryFnData<contracts, allowFailure>,
-    ReadContractsErrorType,
-    ReadContractsData<contracts, allowFailure>,
-    ReadContractsQueryKey<contracts, allowFailure, config>
-  >
+  }
 }
 
 export type ReadContractsQueryFnData<
@@ -78,7 +81,14 @@ export function readContractsQueryKey<
   const contracts extends readonly unknown[],
   allowFailure extends boolean,
 >(
-  options: ReadContractsOptions<contracts, allowFailure, config> &
+  options: ExactPartial<
+    viem_MulticallParameters<
+      contracts,
+      allowFailure,
+      { optional: true; properties: ChainIdParameter<config> }
+    >
+  > &
+    ScopeKeyParameter &
     ChainIdParameter<config> = {},
 ) {
   const contracts = []
@@ -98,3 +108,15 @@ export type ReadContractsQueryKey<
   allowFailure extends boolean,
   config extends Config,
 > = ReturnType<typeof readContractsQueryKey<config, contracts, allowFailure>>
+
+export type ReadContractsQueryOptions<
+  contracts extends readonly unknown[],
+  allowFailure extends boolean,
+  config extends Config,
+  selectData = ReadContractsData<contracts, allowFailure>,
+> = QueryOptions<
+  ReadContractsQueryFnData<contracts, allowFailure>,
+  ReadContractsErrorType,
+  selectData,
+  ReadContractsQueryKey<contracts, allowFailure, config>
+>

package/src/query/simulateContract.ts

@@ -1,4 +1,3 @@
-import type { QueryOptions } from '@tanstack/query-core'
 import type { Abi, ContractFunctionArgs, ContractFunctionName } from 'viem'
 
 import {
@@ -9,6 +8,7 @@ import {
 } from '../actions/simulateContract.js'
 import type { Config } from '../createConfig.js'
 import type { ScopeKeyParameter } from '../types/properties.js'
+import type { QueryOptions, QueryParameter } from '../types/query.js'
 import type { UnionExactPartial } from '../types/utils.js'
 import { filterQueryOptions } from './utils.js'
 
@@ -22,21 +22,29 @@ export type SimulateContractOptions<
   >,
   config extends Config,
   chainId extends config['chains'][number]['id'] | undefined,
+  selectData = SimulateContractData<abi, functionName, args, config, chainId>,
 > = UnionExactPartial<
   SimulateContractParameters<abi, functionName, args, config, chainId>
 > &
-  ScopeKeyParameter
+  ScopeKeyParameter &
+  QueryParameter<
+    SimulateContractQueryFnData<abi, functionName, args, config, chainId>,
+    SimulateContractErrorType,
+    selectData,
+    SimulateContractQueryKey<abi, functionName, args, config, chainId>
+  >
 
 export function simulateContractQueryOptions<
-  config extends Config,
   const abi extends Abi | readonly unknown[],
   functionName extends ContractFunctionName<abi, 'nonpayable' | 'payable'>,
-  args extends ContractFunctionArgs<
+  const args extends ContractFunctionArgs<
     abi,
     'nonpayable' | 'payable',
     functionName
   >,
+  config extends Config,
   chainId extends config['chains'][number]['id'] | undefined,
+  selectData = SimulateContractData<abi, functionName, args, config, chainId>,
 >(
   config: config,
   options: SimulateContractOptions<
@@ -44,30 +52,42 @@ export function simulateContractQueryOptions<
     functionName,
     args,
     config,
-    chainId
+    chainId,
+    selectData
   > = {} as any,
-) {
+): SimulateContractQueryOptions<
+  abi,
+  functionName,
+  args,
+  config,
+  chainId,
+  selectData
+> {
   return {
-    async queryFn({ queryKey }) {
-      const { abi, connector } = options
-      if (!abi) throw new Error('abi is required')
-      const { scopeKey: _, ...parameters } = queryKey[1]
-      const { address, functionName } = parameters
-      if (!address) throw new Error('address is required')
-      if (!functionName) throw new Error('functionName is required')
+    ...options.query,
+    enabled: Boolean(
+      options.abi &&
+        options.address &&
+        options.connector &&
+        options.functionName &&
+        (options.query?.enabled ?? true),
+    ),
+    queryFn: async (context) => {
+      if (!options.abi) throw new Error('abi is required')
+      if (!options.connector) throw new Error('connector is required')
+      const [, { scopeKey: _, ...parameters }] = context.queryKey
+      if (!parameters.address) throw new Error('address is required')
+      if (!parameters.functionName) throw new Error('functionName is required')
       return simulateContract(config, {
-        abi,
-        connector,
         ...(parameters as any),
+        abi: options.abi,
+        address: parameters.address,
+        connector: options.connector,
+        functionName: parameters.functionName,
       })
     },
-    queryKey: simulateContractQueryKey(options),
-  } as const satisfies QueryOptions<
-    SimulateContractQueryFnData<abi, functionName, args, config, chainId>,
-    SimulateContractErrorType,
-    SimulateContractData<abi, functionName, args, config, chainId>,
-    SimulateContractQueryKey<abi, functionName, args, config, chainId>
-  >
+    queryKey: simulateContractQueryKey(options as any),
+  }
 }
 
 export type SimulateContractQueryFnData<
@@ -95,25 +115,22 @@ export type SimulateContractData<
 > = SimulateContractQueryFnData<abi, functionName, args, config, chainId>
 
 export function simulateContractQueryKey<
-  config extends Config,
   abi extends Abi | readonly unknown[],
   functionName extends ContractFunctionName<abi, 'nonpayable' | 'payable'>,
-  args extends ContractFunctionArgs<
+  const args extends ContractFunctionArgs<
     abi,
     'nonpayable' | 'payable',
     functionName
   >,
+  const config extends Config,
   chainId extends config['chains'][number]['id'] | undefined,
 >(
-  options: SimulateContractOptions<
-    abi,
-    functionName,
-    args,
-    config,
-    chainId
-  > = {} as any,
+  options: UnionExactPartial<
+    SimulateContractParameters<abi, functionName, args, config, chainId>
+  > &
+    ScopeKeyParameter = {} as any,
 ) {
-  const { abi: _, connector: _c, ...rest } = options
+  const { connector: _, ...rest } = options
   return ['simulateContract', filterQueryOptions(rest)] as const
 }
 
@@ -128,5 +145,23 @@ export type SimulateContractQueryKey<
   config extends Config,
   chainId extends config['chains'][number]['id'] | undefined,
 > = ReturnType<
-  typeof simulateContractQueryKey<config, abi, functionName, args, chainId>
+  typeof simulateContractQueryKey<abi, functionName, args, config, chainId>
+>
+
+export type SimulateContractQueryOptions<
+  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'] | undefined,
+  selectData = SimulateContractData<abi, functionName, args, config, chainId>,
+> = QueryOptions<
+  SimulateContractQueryFnData<abi, functionName, args, config, chainId>,
+  SimulateContractErrorType,
+  selectData,
+  SimulateContractQueryKey<abi, functionName, args, config, chainId>
 >

package/src/query/utils.ts

@@ -1,4 +1,6 @@
 import { type QueryKey, replaceEqualDeep } from '@tanstack/query-core'
+import type { Connector } from '../createConfig.js'
+import type { Compute, StrictOmit } from '../types/utils.js'
 
 export function structuralSharing<data>(
   oldData: data | undefined,
@@ -47,9 +49,16 @@ function hasObjectPrototype(o: any): boolean {
   return Object.prototype.toString.call(o) === '[object Object]'
 }
 
-export function filterQueryOptions<type extends Record<string, unknown>>(
+export function filterQueryOptions<
+  type extends Record<string, unknown> & { connector?: Connector | undefined },
+>(
   options: type,
-): type {
+): Compute<
+  StrictOmit<type, 'abi' | 'config' | 'connector' | 'query' | 'watch'> &
+    (type extends { connector?: Connector | undefined }
+      ? { connectorUid?: string }
+      : unknown)
+> {
   // destructuring is super fast
   // biome-ignore format: no formatting
   const {
@@ -69,9 +78,9 @@ export function filterQueryOptions<type extends Record<string, unknown>>(
     // wagmi
     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     // biome-ignore lint/correctness/noUnusedVariables: tossing
-    config, connector, query,
+    abi, config, connector, query, watch,
     ...rest
   } = options
-
-  return rest as type
+  if (connector) return { connectorUid: connector?.uid, ...rest } as never
+  return rest as never
 }

package/src/query/verifyMessage.ts

@@ -1,5 +1,3 @@
-import type { QueryOptions } from '@tanstack/query-core'
-
 import {
   type VerifyMessageErrorType,
   type VerifyMessageParameters,
@@ -8,45 +6,61 @@ import {
 } from '../actions/verifyMessage.js'
 import type { Config } from '../createConfig.js'
 import type { ScopeKeyParameter } from '../types/properties.js'
+import type { QueryOptions, QueryParameter } from '../types/query.js'
 import type { Compute, ExactPartial } from '../types/utils.js'
 import { filterQueryOptions } from './utils.js'
 
-export type VerifyMessageOptions<config extends Config> = Compute<
-  ExactPartial<VerifyMessageParameters<config>> & ScopeKeyParameter
->
+export type VerifyMessageOptions<
+  config extends Config,
+  selectData = VerifyMessageData,
+> = Compute<ExactPartial<VerifyMessageParameters<config>> & ScopeKeyParameter> &
+  QueryParameter<
+    VerifyMessageQueryFnData,
+    VerifyMessageErrorType,
+    selectData,
+    VerifyMessageQueryKey<config>
+  >
 
-export function verifyMessageQueryOptions<config extends Config>(
+export function verifyMessageQueryOptions<
+  config extends Config,
+  selectData = VerifyMessageData,
+>(
   config: config,
-  options: VerifyMessageOptions<config> = {},
-) {
+  options: VerifyMessageOptions<config, selectData> = {},
+): VerifyMessageQueryOptions<config, selectData> {
   return {
-    async queryFn({ queryKey }) {
-      const { address, message, signature } = queryKey[1]
-      if (!address || !message || !signature)
-        throw new Error('address, message, and signature are required')
-
-      const { scopeKey: _, ...parameters } = queryKey[1]
-
-      const verified = await verifyMessage(
-        config,
-        parameters as VerifyMessageParameters,
-      )
+    ...options.query,
+    enabled: Boolean(
+      options.address &&
+        options.message &&
+        options.signature &&
+        (options.query?.enabled ?? true),
+    ),
+    queryFn: async (context) => {
+      const [, { scopeKey: _, ...parameters }] = context.queryKey
+      if (!parameters.address) throw new Error('address is required')
+      if (!parameters.message) throw new Error('message is required')
+      if (!parameters.signature) throw new Error('signature is required')
+      const verified = await verifyMessage(config, {
+        ...parameters,
+        address: parameters.address,
+        message: parameters.message,
+        signature: parameters.signature,
+      })
       return verified ?? null
     },
     queryKey: verifyMessageQueryKey(options),
-  } as const satisfies QueryOptions<
-    VerifyMessageQueryFnData,
-    VerifyMessageErrorType,
-    VerifyMessageData,
-    VerifyMessageQueryKey<config>
-  >
+  }
 }
+
 export type VerifyMessageQueryFnData = VerifyMessageReturnType
 
 export type VerifyMessageData = VerifyMessageQueryFnData
 
 export function verifyMessageQueryKey<config extends Config>(
-  options: VerifyMessageOptions<config>,
+  options: Compute<
+    ExactPartial<VerifyMessageParameters<config>> & ScopeKeyParameter
+  > = {},
 ) {
   return ['verifyMessage', filterQueryOptions(options)] as const
 }
@@ -54,3 +68,13 @@ export function verifyMessageQueryKey<config extends Config>(
 export type VerifyMessageQueryKey<config extends Config> = ReturnType<
   typeof verifyMessageQueryKey<config>
 >
+
+export type VerifyMessageQueryOptions<
+  config extends Config,
+  selectData = VerifyMessageData,
+> = QueryOptions<
+  VerifyMessageQueryFnData,
+  VerifyMessageErrorType,
+  selectData,
+  VerifyMessageQueryKey<config>
+>

package/src/query/verifyTypedData.ts

@@ -1,4 +1,3 @@
-import type { QueryOptions } from '@tanstack/query-core'
 import type { TypedData } from 'viem'
 
 import {
@@ -9,58 +8,69 @@ import {
 } from '../actions/verifyTypedData.js'
 import type { Config } from '../createConfig.js'
 import type { ScopeKeyParameter } from '../types/properties.js'
-import type { ExactPartial } from '../types/utils.js'
+import type { QueryOptions, QueryParameter } from '../types/query.js'
+import type { UnionExactPartial } from '../types/utils.js'
 import { filterQueryOptions } from './utils.js'
 
 export type VerifyTypedDataOptions<
   typedData extends TypedData | Record<string, unknown>,
   primaryType extends keyof typedData | 'EIP712Domain',
   config extends Config,
-> = ExactPartial<VerifyTypedDataParameters<typedData, primaryType, config>> &
-  ScopeKeyParameter
+  selectData = VerifyTypedDataData,
+> = UnionExactPartial<
+  VerifyTypedDataParameters<typedData, primaryType, config>
+> &
+  ScopeKeyParameter &
+  QueryParameter<
+    VerifyTypedDataQueryFnData,
+    VerifyTypedDataErrorType,
+    selectData,
+    VerifyTypedDataQueryKey<typedData, primaryType, config>
+  >
 
 export function verifyTypedDataQueryOptions<
-  config extends Config,
   const typedData extends TypedData | Record<string, unknown>,
   primaryType extends keyof typedData | 'EIP712Domain',
+  config extends Config,
+  selectData = VerifyTypedDataData,
 >(
   config: config,
-  options: VerifyTypedDataOptions<typedData, primaryType, config> = {} as any,
-) {
+  options: VerifyTypedDataOptions<
+    typedData,
+    primaryType,
+    config,
+    selectData
+  > = {} as any,
+): VerifyTypedDataQueryOptions<typedData, primaryType, config, selectData> {
   return {
-    async queryFn({ queryKey }) {
-      const {
-        address,
-        message,
-        primaryType,
-        signature,
-        types,
-        scopeKey: _,
-        ...parameters
-      } = queryKey[1]
-      if (!address) throw new Error('address is required')
-      if (!message) throw new Error('message is required')
-      if (!primaryType) throw new Error('primaryType is required')
-      if (!signature) throw new Error('signature is required')
-      if (!types) throw new Error('types is required')
-
+    ...options.query,
+    enabled: Boolean(
+      options.address &&
+        options.message &&
+        options.primaryType &&
+        options.signature &&
+        options.types &&
+        (options.query?.enabled ?? true),
+    ),
+    queryFn: async (context) => {
+      const [, { scopeKey: _, ...parameters }] = context.queryKey
+      if (!parameters.address) throw new Error('address is required')
+      if (!parameters.message) throw new Error('message is required')
+      if (!parameters.primaryType) throw new Error('primaryType is required')
+      if (!parameters.signature) throw new Error('signature is required')
+      if (!parameters.types) throw new Error('types is required')
       const verified = await verifyTypedData(config, {
-        ...parameters,
-        address,
-        message,
-        primaryType,
-        signature,
-        types,
-      } as VerifyTypedDataParameters)
+        ...(parameters as any),
+        address: parameters.address,
+        message: parameters.message,
+        primaryType: parameters.primaryType,
+        signature: parameters.signature,
+        types: parameters.types,
+      })
       return verified ?? null
     },
-    queryKey: verifyTypedDataQueryKey(options),
-  } as const satisfies QueryOptions<
-    VerifyTypedDataQueryFnData,
-    VerifyTypedDataErrorType,
-    VerifyTypedDataData,
-    VerifyTypedDataQueryKey<typedData, primaryType, config>
-  >
+    queryKey: verifyTypedDataQueryKey(options as any) as any,
+  }
 }
 
 export type VerifyTypedDataQueryFnData = VerifyTypedDataReturnType
@@ -71,7 +81,12 @@ export function verifyTypedDataQueryKey<
   config extends Config,
   const typedData extends TypedData | Record<string, unknown>,
   primaryType extends keyof typedData | 'EIP712Domain',
->(options: VerifyTypedDataOptions<typedData, primaryType, config>) {
+>(
+  options: UnionExactPartial<
+    VerifyTypedDataParameters<typedData, primaryType, config>
+  > &
+    ScopeKeyParameter = {} as any,
+) {
   return ['verifyTypedData', filterQueryOptions(options)] as const
 }
 
@@ -80,3 +95,15 @@ export type VerifyTypedDataQueryKey<
   primaryType extends keyof typedData | 'EIP712Domain',
   config extends Config,
 > = ReturnType<typeof verifyTypedDataQueryKey<config, typedData, primaryType>>
+
+export type VerifyTypedDataQueryOptions<
+  typedData extends TypedData | Record<string, unknown>,
+  primaryType extends keyof typedData | 'EIP712Domain',
+  config extends Config,
+  selectData = VerifyTypedDataData,
+> = QueryOptions<
+  VerifyTypedDataQueryFnData,
+  VerifyTypedDataErrorType,
+  selectData,
+  VerifyTypedDataQueryKey<typedData, primaryType, config>
+>

package/src/query/waitForCallsStatus.ts

@@ -1,5 +1,3 @@
-import type { QueryOptions } from '@tanstack/query-core'
-
 import {
   type WaitForCallsStatusErrorType,
   type WaitForCallsStatusParameters,
@@ -7,47 +5,71 @@ import {
   waitForCallsStatus,
 } from '../actions/waitForCallsStatus.js'
 import type { Config } from '../createConfig.js'
-import { ConnectorNotConnectedError } from '../errors/config.js'
 import { filterQueryOptions } from '../query/utils.js'
 import type { ScopeKeyParameter } from '../types/properties.js'
-import type { Compute, PartialBy } from '../types/utils.js'
+import type { QueryOptions, QueryParameter } from '../types/query.js'
+import type { Compute, ExactPartial } from '../types/utils.js'
 
-export type WaitForCallsStatusOptions = Compute<
-  PartialBy<WaitForCallsStatusParameters, 'id'> & ScopeKeyParameter
->
+export type WaitForCallsStatusOptions<selectData = WaitForCallsStatusData> =
+  Compute<ExactPartial<WaitForCallsStatusParameters> & ScopeKeyParameter> &
+    QueryParameter<
+      WaitForCallsStatusQueryFnData,
+      WaitForCallsStatusErrorType,
+      selectData,
+      WaitForCallsStatusQueryKey
+    >
 
-export function waitForCallsStatusQueryOptions<config extends Config>(
+export function waitForCallsStatusQueryOptions<
+  config extends Config,
+  selectData = WaitForCallsStatusData,
+>(
   config: config,
-  options: WaitForCallsStatusOptions,
-) {
+  options: WaitForCallsStatusOptions<selectData>,
+): WaitForCallsStatusQueryOptions<selectData> {
   return {
-    async queryFn({ queryKey }) {
-      const { scopeKey: _, id, ...parameters } = queryKey[1]
-      if (!id) throw new Error('id is required')
-      const status = await waitForCallsStatus(config, { ...parameters, id })
+    ...options.query,
+    enabled: Boolean(
+      options.id &&
+        options.connector?.getProvider &&
+        (options.query?.enabled ?? true),
+    ),
+    queryFn: async (context) => {
+      if (!options.connector?.getProvider)
+        throw new Error('connector is required')
+      const [, { connectorUid: _, scopeKey: __, ...parameters }] =
+        context.queryKey
+      if (!parameters.id) throw new Error('id is required')
+      const status = await waitForCallsStatus(config, {
+        ...parameters,
+        id: parameters.id,
+      })
       return status
     },
     queryKey: waitForCallsStatusQueryKey(options),
-    retry(failureCount, error) {
-      if (error instanceof ConnectorNotConnectedError) return false
-      return failureCount < 3
-    },
-  } as const satisfies QueryOptions<
-    WaitForCallsStatusQueryFnData,
-    WaitForCallsStatusErrorType,
-    WaitForCallsStatusData,
-    WaitForCallsStatusQueryKey
-  >
+  }
 }
 
 export type WaitForCallsStatusQueryFnData = WaitForCallsStatusReturnType
 
 export type WaitForCallsStatusData = WaitForCallsStatusQueryFnData
 
-export function waitForCallsStatusQueryKey(options: WaitForCallsStatusOptions) {
+export function waitForCallsStatusQueryKey(
+  options: Compute<
+    ExactPartial<WaitForCallsStatusParameters> & ScopeKeyParameter
+  > = {},
+) {
   return ['callsStatus', filterQueryOptions(options)] as const
 }
 
 export type WaitForCallsStatusQueryKey = ReturnType<
   typeof waitForCallsStatusQueryKey
 >
+
+export type WaitForCallsStatusQueryOptions<
+  selectData = WaitForCallsStatusData,
+> = QueryOptions<
+  WaitForCallsStatusQueryFnData,
+  WaitForCallsStatusErrorType,
+  selectData,
+  WaitForCallsStatusQueryKey
+>