@wagmi/core 3.2.1 → 3.2.2

package/src/query/getTransactionCount.ts

@@ -1,5 +1,3 @@
-import type { QueryOptions } from '@tanstack/query-core'
-
 import {
   type GetTransactionCountErrorType,
   type GetTransactionCountParameters,
@@ -8,35 +6,44 @@ import {
 } from '../actions/getTransactionCount.js'
 import type { Config } from '../createConfig.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'
 import { filterQueryOptions } from './utils.js'
 
-export type GetTransactionCountOptions<config extends Config> = Compute<
-  PartialBy<GetTransactionCountParameters<config>, 'address'> &
-    ScopeKeyParameter
->
+export type GetTransactionCountOptions<
+  config extends Config,
+  selectData = GetTransactionCountData,
+> = Compute<
+  ExactPartial<GetTransactionCountParameters<config>> & ScopeKeyParameter
+> &
+  QueryParameter<
+    GetTransactionCountQueryFnData,
+    GetTransactionCountErrorType,
+    selectData,
+    GetTransactionCountQueryKey<config>
+  >
 
-export function getTransactionCountQueryOptions<config extends Config>(
+export function getTransactionCountQueryOptions<
+  config extends Config,
+  selectData = GetTransactionCountData,
+>(
   config: config,
-  options: GetTransactionCountOptions<config> = {},
-) {
+  options: GetTransactionCountOptions<config, selectData> = {},
+): GetTransactionCountQueryOptions<config, selectData> {
   return {
-    async queryFn({ queryKey }) {
-      const { address, scopeKey: _, ...parameters } = queryKey[1]
-      if (!address) throw new Error('address is required')
+    ...options.query,
+    enabled: Boolean(options.address && (options.query?.enabled ?? true)),
+    queryFn: async (context) => {
+      const [, { scopeKey: _, ...parameters }] = context.queryKey
+      if (!parameters.address) throw new Error('address is required')
       const transactionCount = await getTransactionCount(config, {
-        ...(parameters as GetTransactionCountParameters),
-        address,
+        ...(parameters as any),
+        address: parameters.address,
       })
       return transactionCount ?? null
     },
     queryKey: getTransactionCountQueryKey(options),
-  } as const satisfies QueryOptions<
-    GetTransactionCountQueryFnData,
-    GetTransactionCountErrorType,
-    GetTransactionCountData,
-    GetTransactionCountQueryKey<config>
-  >
+  }
 }
 
 export type GetTransactionCountQueryFnData =
@@ -45,7 +52,9 @@ export type GetTransactionCountQueryFnData =
 export type GetTransactionCountData = GetTransactionCountQueryFnData
 
 export function getTransactionCountQueryKey<config extends Config>(
-  options: GetTransactionCountOptions<config> = {},
+  options: Compute<
+    ExactPartial<GetTransactionCountParameters<config>> & ScopeKeyParameter
+  > = {},
 ) {
   return ['transactionCount', filterQueryOptions(options)] as const
 }
@@ -53,3 +62,13 @@ export function getTransactionCountQueryKey<config extends Config>(
 export type GetTransactionCountQueryKey<config extends Config> = ReturnType<
   typeof getTransactionCountQueryKey<config>
 >
+
+export type GetTransactionCountQueryOptions<
+  config extends Config,
+  selectData = GetTransactionCountData,
+> = QueryOptions<
+  GetTransactionCountQueryFnData,
+  GetTransactionCountErrorType,
+  selectData,
+  GetTransactionCountQueryKey<config>
+>

package/src/query/getTransactionReceipt.ts

@@ -1,4 +1,3 @@
-import type { QueryOptions } from '@tanstack/query-core'
 import type { GetTransactionReceiptReturnType } from '../actions/getTransactionReceipt.js'
 import {
   type GetTransactionReceiptErrorType,
@@ -7,35 +6,48 @@ import {
 } from '../actions/getTransactionReceipt.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 GetTransactionReceiptOptions<
   config extends Config,
   chainId extends config['chains'][number]['id'],
+  selectData = GetTransactionReceiptData<config, chainId>,
 > = Compute<
   ExactPartial<GetTransactionReceiptParameters<config, chainId>> &
     ScopeKeyParameter
->
+> &
+  QueryParameter<
+    GetTransactionReceiptQueryFnData<config, chainId>,
+    GetTransactionReceiptErrorType,
+    selectData,
+    GetTransactionReceiptQueryKey<config, chainId>
+  >
 
 export function getTransactionReceiptQueryOptions<
   config extends Config,
   chainId extends config['chains'][number]['id'],
->(config: config, options: GetTransactionReceiptOptions<config, chainId> = {}) {
+  selectData = GetTransactionReceiptData<config, chainId>,
+>(
+  config: config,
+  options: GetTransactionReceiptOptions<config, chainId, selectData> = {},
+): GetTransactionReceiptQueryOptions<config, chainId, selectData> {
   return {
-    queryFn({ queryKey }) {
-      const { hash, scopeKey: _, ...parameters } = queryKey[1]
-      if (!hash) throw new Error('hash is required')
-      return getTransactionReceipt(config, { ...parameters, hash })
+    ...options.query,
+    enabled: Boolean(options.hash && (options.query?.enabled ?? true)),
+    queryFn: async (context) => {
+      const [, { scopeKey: _, ...parameters }] = context.queryKey
+      if (!parameters.hash) throw new Error('hash is required')
+      return getTransactionReceipt(config, {
+        ...(parameters as any),
+        hash: parameters.hash,
+      })
     },
     queryKey: getTransactionReceiptQueryKey(options),
-  } as const satisfies QueryOptions<
-    GetTransactionReceiptQueryFnData<config, chainId>,
-    GetTransactionReceiptErrorType,
-    GetTransactionReceiptData<config, chainId>,
-    GetTransactionReceiptQueryKey<config, chainId>
-  >
+  }
 }
+
 export type GetTransactionReceiptQueryFnData<
   config extends Config,
   chainId extends config['chains'][number]['id'],
@@ -49,7 +61,12 @@ export type GetTransactionReceiptData<
 export function getTransactionReceiptQueryKey<
   config extends Config,
   chainId extends config['chains'][number]['id'],
->(options: GetTransactionReceiptOptions<config, chainId>) {
+>(
+  options: Compute<
+    ExactPartial<GetTransactionReceiptParameters<config, chainId>> &
+      ScopeKeyParameter
+  > = {},
+) {
   return ['getTransactionReceipt', filterQueryOptions(options)] as const
 }
 
@@ -57,3 +74,14 @@ export type GetTransactionReceiptQueryKey<
   config extends Config,
   chainId extends config['chains'][number]['id'],
 > = ReturnType<typeof getTransactionReceiptQueryKey<config, chainId>>
+
+export type GetTransactionReceiptQueryOptions<
+  config extends Config,
+  chainId extends config['chains'][number]['id'],
+  selectData = GetTransactionReceiptData<config, chainId>,
+> = QueryOptions<
+  GetTransactionReceiptQueryFnData<config, chainId>,
+  GetTransactionReceiptErrorType,
+  selectData,
+  GetTransactionReceiptQueryKey<config, chainId>
+>

package/src/query/getWalletClient.ts

@@ -1,5 +1,3 @@
-import type { QueryOptions } from '@tanstack/query-core'
-
 import {
   type GetWalletClientErrorType,
   type GetWalletClientParameters,
@@ -8,34 +6,51 @@ import {
 } from '../actions/getWalletClient.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 GetWalletClientOptions<
   config extends Config,
   chainId extends config['chains'][number]['id'],
+  selectData = GetWalletClientData<config, chainId>,
 > = Compute<
   ExactPartial<GetWalletClientParameters<config, chainId>> & ScopeKeyParameter
->
+> &
+  QueryParameter<
+    GetWalletClientQueryFnData<config, chainId>,
+    GetWalletClientErrorType,
+    selectData,
+    GetWalletClientQueryKey<config, chainId>
+  >
 
 export function getWalletClientQueryOptions<
   config extends Config,
   chainId extends config['chains'][number]['id'],
->(config: config, options: GetWalletClientOptions<config, chainId> = {}) {
+  selectData = GetWalletClientData<config, chainId>,
+>(
+  config: config,
+  options: GetWalletClientOptions<config, chainId, selectData> = {},
+): GetWalletClientQueryOptions<config, chainId, selectData> {
   return {
+    ...options.query,
+    enabled: Boolean(
+      options.connector?.getProvider && (options.query?.enabled ?? true),
+    ),
     gcTime: 0,
-    async queryFn({ queryKey }) {
-      const { connector } = options
-      const { connectorUid: _, scopeKey: _s, ...parameters } = queryKey[1]
-      return getWalletClient(config, { ...parameters, connector }) as never
+    queryFn: async (context) => {
+      if (!options.connector?.getProvider)
+        throw new Error('connector is required')
+      const [, { connectorUid: _, scopeKey: __, ...parameters }] =
+        context.queryKey
+      return getWalletClient(config, {
+        ...parameters,
+        connector: options.connector,
+      }) as never
     },
     queryKey: getWalletClientQueryKey(options),
-  } as const satisfies QueryOptions<
-    GetWalletClientQueryFnData<config, chainId>,
-    GetWalletClientErrorType,
-    GetWalletClientData<config, chainId>,
-    GetWalletClientQueryKey<config, chainId>
-  >
+    staleTime: Number.POSITIVE_INFINITY,
+  }
 }
 
 export type GetWalletClientQueryFnData<
@@ -51,15 +66,26 @@ export type GetWalletClientData<
 export function getWalletClientQueryKey<
   config extends Config,
   chainId extends config['chains'][number]['id'],
->(options: GetWalletClientOptions<config, chainId> = {}) {
-  const { connector, ...parameters } = options
-  return [
-    'walletClient',
-    { ...filterQueryOptions(parameters), connectorUid: connector?.uid },
-  ] as const
+>(
+  options: Compute<
+    ExactPartial<GetWalletClientParameters<config, chainId>> & ScopeKeyParameter
+  > = {},
+) {
+  return ['walletClient', filterQueryOptions(options)] as const
 }
 
 export type GetWalletClientQueryKey<
   config extends Config,
   chainId extends config['chains'][number]['id'],
 > = ReturnType<typeof getWalletClientQueryKey<config, chainId>>
+
+export type GetWalletClientQueryOptions<
+  config extends Config,
+  chainId extends config['chains'][number]['id'],
+  selectData = GetWalletClientData<config, chainId>,
+> = QueryOptions<
+  GetWalletClientQueryFnData<config, chainId>,
+  GetWalletClientErrorType,
+  selectData,
+  GetWalletClientQueryKey<config, chainId>
+>

package/src/query/infiniteReadContracts.ts

@@ -108,7 +108,7 @@ export function infiniteReadContractsQueryKey<
     ChainIdParameter<config> &
     RequiredPageParamsParameters<contracts, allowFailure, pageParam>,
 ) {
-  const { contracts: _, query: _q, ...parameters } = options
+  const { contracts: _, ...parameters } = options
   return ['infiniteReadContracts', filterQueryOptions(parameters)] as const
 }
 

package/src/query/prepareTransactionRequest.ts

@@ -1,5 +1,3 @@
-import type { QueryOptions } from '@tanstack/query-core'
-
 import type { PrepareTransactionRequestRequest as viem_PrepareTransactionRequestRequest } from 'viem'
 
 import {
@@ -11,6 +9,7 @@ import {
 import type { Config } from '../createConfig.js'
 import type { SelectChains } from '../types/chain.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'
 
@@ -21,10 +20,17 @@ export type PrepareTransactionRequestOptions<
     SelectChains<config, chainId>[0],
     SelectChains<config, chainId>[0]
   >,
+  selectData = PrepareTransactionRequestData<config, chainId, request>,
 > = UnionExactPartial<
   PrepareTransactionRequestParameters<config, chainId, request>
 > &
-  ScopeKeyParameter
+  ScopeKeyParameter &
+  QueryParameter<
+    PrepareTransactionRequestQueryFnData<config, chainId, request>,
+    PrepareTransactionRequestErrorType,
+    selectData,
+    PrepareTransactionRequestQueryKey<config, chainId, request>
+  >
 
 export function prepareTransactionRequestQueryOptions<
   config extends Config,
@@ -33,33 +39,35 @@ export function prepareTransactionRequestQueryOptions<
     SelectChains<config, chainId>[0],
     SelectChains<config, chainId>[0]
   >,
+  selectData = PrepareTransactionRequestData<config, chainId, request>,
 >(
   config: config,
   options: PrepareTransactionRequestOptions<
     config,
     chainId,
-    request
+    request,
+    selectData
   > = {} as any,
-) {
+): PrepareTransactionRequestQueryOptions<config, chainId, request, selectData> {
   return {
-    queryFn({ queryKey }) {
-      const { scopeKey: _, to, ...parameters } = queryKey[1]
-      if (!to) throw new Error('to is required')
+    ...options.query,
+    enabled: Boolean(options.to && (options.query?.enabled ?? true)),
+    queryFn: async (context) => {
+      const [, { scopeKey: _, ...parameters }] = context.queryKey
+      if (!parameters.to) throw new Error('to is required')
       return prepareTransactionRequest(config, {
-        to,
         ...(parameters as any),
+        to: parameters.to,
       }) as unknown as Promise<
         PrepareTransactionRequestQueryFnData<config, chainId, request>
       >
     },
-    queryKey: prepareTransactionRequestQueryKey(options),
-  } as const satisfies QueryOptions<
-    PrepareTransactionRequestQueryFnData<config, chainId, request>,
-    PrepareTransactionRequestErrorType,
-    PrepareTransactionRequestData<config, chainId, request>,
-    PrepareTransactionRequestQueryKey<config, chainId, request>
-  >
+    queryKey: prepareTransactionRequestQueryKey(
+      options,
+    ) as PrepareTransactionRequestQueryKey<config, chainId, request>,
+  }
 }
+
 export type PrepareTransactionRequestQueryFnData<
   config extends Config,
   chainId extends config['chains'][number]['id'] | undefined,
@@ -85,7 +93,12 @@ export function prepareTransactionRequestQueryKey<
     SelectChains<config, chainId>[0],
     SelectChains<config, chainId>[0]
   >,
->(options: PrepareTransactionRequestOptions<config, chainId, request>) {
+>(
+  options: UnionExactPartial<
+    PrepareTransactionRequestParameters<config, chainId, request>
+  > &
+    ScopeKeyParameter = {} as any,
+) {
   return ['prepareTransactionRequest', filterQueryOptions(options)] as const
 }
 
@@ -99,3 +112,18 @@ export type PrepareTransactionRequestQueryKey<
 > = ReturnType<
   typeof prepareTransactionRequestQueryKey<config, chainId, request>
 >
+
+export type PrepareTransactionRequestQueryOptions<
+  config extends Config,
+  chainId extends config['chains'][number]['id'] | undefined,
+  request extends viem_PrepareTransactionRequestRequest<
+    SelectChains<config, chainId>[0],
+    SelectChains<config, chainId>[0]
+  >,
+  selectData = PrepareTransactionRequestData<config, chainId, request>,
+> = QueryOptions<
+  PrepareTransactionRequestQueryFnData<config, chainId, request>,
+  PrepareTransactionRequestErrorType,
+  selectData,
+  PrepareTransactionRequestQueryKey<config, chainId, request>
+>

package/src/query/readContract.ts

@@ -1,6 +1,4 @@
-import type { QueryOptions } from '@tanstack/query-core'
 import type { Abi, ContractFunctionArgs, ContractFunctionName } from 'viem'
-
 import {
   type ReadContractErrorType,
   type ReadContractParameters,
@@ -9,58 +7,62 @@ import {
 } from '../actions/readContract.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'
+import { filterQueryOptions, structuralSharing } from './utils.js'
 
 export type ReadContractOptions<
   abi extends Abi | readonly unknown[],
   functionName extends ContractFunctionName<abi, 'pure' | 'view'>,
   args extends ContractFunctionArgs<abi, 'pure' | 'view', functionName>,
   config extends Config,
+  selectData = ReadContractData<abi, functionName, args>,
 > = UnionExactPartial<ReadContractParameters<abi, functionName, args, config>> &
-  ScopeKeyParameter
+  ScopeKeyParameter &
+  QueryParameter<
+    ReadContractQueryFnData<abi, functionName, args>,
+    ReadContractErrorType,
+    selectData,
+    ReadContractQueryKey<abi, functionName, args, config>
+  >
 
 export function readContractQueryOptions<
   config extends Config,
   const abi extends Abi | readonly unknown[],
   functionName extends ContractFunctionName<abi, 'pure' | 'view'>,
-  args extends ContractFunctionArgs<abi, 'pure' | 'view', functionName>,
+  const args extends ContractFunctionArgs<abi, 'pure' | 'view', functionName>,
+  selectData = ReadContractData<abi, functionName, args>,
 >(
   config: config,
   options: ReadContractOptions<abi, functionName, args, config> = {} as any,
-) {
+): ReadContractQueryOptions<abi, functionName, args, config, selectData> {
   return {
+    ...options.query,
+    enabled: Boolean(
+      Boolean(options.address || ('code' in options && options.code)) &&
+        options.abi &&
+        options.functionName &&
+        (options.query?.enabled ?? true),
+    ),
     // TODO: Support `signal` once Viem actions allow passthrough
     // https://tkdodo.eu/blog/why-you-want-react-query#bonus-cancellation
-    async queryFn({ queryKey }) {
-      const abi = options.abi as Abi
-      if (!abi) throw new Error('abi is required')
-
-      const { functionName, scopeKey: _, ...parameters } = queryKey[1]
-      const addressOrCodeParams = (() => {
-        const params = queryKey[1] as unknown as ReadContractParameters
-        if (params.address) return { address: params.address }
-        if (params.code) return { code: params.code }
-        throw new Error('address or code is required')
-      })()
-
-      if (!functionName) throw new Error('functionName is required')
-
-      return readContract(config, {
-        abi,
-        functionName,
-        args: parameters.args as readonly unknown[],
-        ...addressOrCodeParams,
-        ...parameters,
-      }) as Promise<ReadContractData<abi, functionName, args>>
+    queryFn: async (context) => {
+      if (!options.abi) throw new Error('abi is required')
+      const [, { scopeKey: _, ...parameters }] = context.queryKey
+      if (!parameters.functionName) throw new Error('functionName is required')
+      const result = await readContract(config, {
+        ...(parameters as any),
+        abi: options.abi,
+        address: parameters.address,
+        code:
+          'code' in parameters && parameters.code ? parameters.code : undefined,
+        functionName: parameters.functionName,
+      })
+      return result as ReadContractData<abi, functionName, args>
     },
     queryKey: readContractQueryKey(options as any) as any,
-  } as const satisfies QueryOptions<
-    ReadContractQueryFnData<abi, functionName, args>,
-    ReadContractErrorType,
-    ReadContractData<abi, functionName, args>,
-    ReadContractQueryKey<abi, functionName, args, config>
-  >
+    structuralSharing,
+  } as ReadContractQueryOptions<abi, functionName, args, config, selectData>
 }
 
 export type ReadContractQueryFnData<
@@ -80,9 +82,13 @@ export function readContractQueryKey<
   const abi extends Abi | readonly unknown[],
   functionName extends ContractFunctionName<abi, 'pure' | 'view'>,
   args extends ContractFunctionArgs<abi, 'pure' | 'view', functionName>,
->(options: ReadContractOptions<abi, functionName, args, config> = {} as any) {
-  const { abi: _, ...rest } = options
-  return ['readContract', filterQueryOptions(rest)] as const
+>(
+  options: UnionExactPartial<
+    ReadContractParameters<abi, functionName, args, config>
+  > &
+    ScopeKeyParameter = {} as any,
+) {
+  return ['readContract', filterQueryOptions(options)] as const
 }
 
 export type ReadContractQueryKey<
@@ -91,3 +97,16 @@ export type ReadContractQueryKey<
   args extends ContractFunctionArgs<abi, 'pure' | 'view', functionName>,
   config extends Config,
 > = ReturnType<typeof readContractQueryKey<config, abi, functionName, args>>
+
+export type ReadContractQueryOptions<
+  abi extends Abi | readonly unknown[],
+  functionName extends ContractFunctionName<abi, 'pure' | 'view'>,
+  args extends ContractFunctionArgs<abi, 'pure' | 'view', functionName>,
+  config extends Config,
+  selectData = ReadContractData<abi, functionName, args>,
+> = QueryOptions<
+  ReadContractQueryFnData<abi, functionName, args>,
+  ReadContractErrorType,
+  selectData,
+  ReadContractQueryKey<abi, functionName, args, config>
+>

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>
+>