@wagmi/core 2.0.0 → 2.0.2

package/src/query/getGasPrice.ts

@@ -0,0 +1,54 @@
+import { type QueryOptions } from '@tanstack/query-core'
+
+import {
+  type GetGasPriceErrorType,
+  type GetGasPriceParameters,
+  type GetGasPriceReturnType,
+  getGasPrice,
+} from '../actions/getGasPrice.js'
+import { type Config } from '../createConfig.js'
+import { type ScopeKeyParameter } from '../types/properties.js'
+import { type Evaluate, type ExactPartial } from '../types/utils.js'
+import { filterQueryOptions } from './utils.js'
+
+export type GetGasPriceOptions<
+  config extends Config,
+  chainId extends config['chains'][number]['id'],
+> = Evaluate<
+  ExactPartial<GetGasPriceParameters<config, chainId>> & ScopeKeyParameter
+>
+
+export function getGasPriceQueryOptions<
+  config extends Config,
+  chainId extends config['chains'][number]['id'],
+>(config: config, options: GetGasPriceOptions<config, chainId> = {}) {
+  return {
+    async queryFn({ queryKey }) {
+      const { scopeKey: _, ...parameters } = queryKey[1]
+      const gasPrice = await getGasPrice(config, parameters)
+      return gasPrice ?? null
+    },
+    queryKey: getGasPriceQueryKey(options),
+  } as const satisfies QueryOptions<
+    GetGasPriceQueryFnData,
+    GetGasPriceErrorType,
+    GetGasPriceData,
+    GetGasPriceQueryKey<config, chainId>
+  >
+}
+
+export type GetGasPriceQueryFnData = GetGasPriceReturnType
+
+export type GetGasPriceData = GetGasPriceQueryFnData
+
+export function getGasPriceQueryKey<
+  config extends Config,
+  chainId extends config['chains'][number]['id'],
+>(options: GetGasPriceOptions<config, chainId> = {}) {
+  return ['gasPrice', filterQueryOptions(options)] as const
+}
+
+export type GetGasPriceQueryKey<
+  config extends Config,
+  chainId extends config['chains'][number]['id'],
+> = ReturnType<typeof getGasPriceQueryKey<config, chainId>>

package/src/query/getToken.ts

@@ -1,14 +1,14 @@
 import { type QueryOptions } from '@tanstack/query-core'
 
 import {
-  type GetTokenError,
+  type GetTokenErrorType,
   type GetTokenParameters,
   type GetTokenReturnType,
   getToken,
 } from '../actions/getToken.js'
-import type { Config } from '../createConfig.js'
+import { type Config } from '../createConfig.js'
+import type { ScopeKeyParameter } from '../types/properties.js'
 import type { Evaluate, ExactPartial } from '../types/utils.js'
-import type { ScopeKeyParameter } from './types.js'
 import { filterQueryOptions } from './utils.js'
 
 export type GetTokenOptions<config extends Config> = Evaluate<
@@ -28,7 +28,7 @@ export function getTokenQueryOptions<config extends Config>(
     queryKey: getTokenQueryKey(options),
   } as const satisfies QueryOptions<
     GetTokenQueryFnData,
-    GetTokenError,
+    GetTokenErrorType,
     GetTokenData,
     GetTokenQueryKey<config>
   >

package/src/query/getTransaction.ts

@@ -1,14 +1,14 @@
 import { type QueryOptions } from '@tanstack/query-core'
 
 import {
-  type GetTransactionError,
+  type GetTransactionErrorType,
   type GetTransactionParameters,
   type GetTransactionReturnType,
   getTransaction,
 } from '../actions/getTransaction.js'
-import type { Config } from '../createConfig.js'
+import { type Config } from '../createConfig.js'
+import type { ScopeKeyParameter } from '../types/properties.js'
 import type { Evaluate, ExactPartial } from '../types/utils.js'
-import type { ScopeKeyParameter } from './types.js'
 import { filterQueryOptions } from './utils.js'
 
 export type GetTransactionOptions<
@@ -24,29 +24,23 @@ export function getTransactionQueryOptions<
 >(config: config, options: GetTransactionOptions<config, chainId> = {}) {
   return {
     async queryFn({ queryKey }) {
-      const {
-        blockHash,
-        blockNumber,
-        blockTag,
-        hash,
-        index,
-        scopeKey: _,
-      } = queryKey[1]
+      const { blockHash, blockNumber, blockTag, hash, index } = queryKey[1]
       if (!blockHash && !blockNumber && !blockTag && !hash)
         throw new Error('blockHash, blockNumber, blockTag, or hash is required')
       if (!hash && !index)
         throw new Error(
           'index is required for blockHash, blockNumber, or blockTag',
         )
+      const { scopeKey: _, ...rest } = queryKey[1]
       return getTransaction(
         config,
-        queryKey[1] as GetTransactionParameters,
+        rest as GetTransactionParameters,
       ) as unknown as Promise<GetTransactionQueryFnData<config, chainId>>
     },
     queryKey: getTransactionQueryKey(options),
   } as const satisfies QueryOptions<
     GetTransactionQueryFnData<config, chainId>,
-    GetTransactionError,
+    GetTransactionErrorType,
     GetTransactionData<config, chainId>,
     GetTransactionQueryKey<config, chainId>
   >

package/src/query/getTransactionCount.ts

@@ -0,0 +1,55 @@
+import { type QueryOptions } from '@tanstack/query-core'
+
+import {
+  type GetTransactionCountErrorType,
+  type GetTransactionCountParameters,
+  type GetTransactionCountReturnType,
+  getTransactionCount,
+} from '../actions/getTransactionCount.js'
+import { type Config } from '../createConfig.js'
+import type { ScopeKeyParameter } from '../types/properties.js'
+import type { Evaluate, PartialBy } from '../types/utils.js'
+import { filterQueryOptions } from './utils.js'
+
+export type GetTransactionCountOptions<config extends Config> = Evaluate<
+  PartialBy<GetTransactionCountParameters<config>, 'address'> &
+    ScopeKeyParameter
+>
+
+export function getTransactionCountQueryOptions<config extends Config>(
+  config: config,
+  options: GetTransactionCountOptions<config> = {},
+) {
+  return {
+    async queryFn({ queryKey }) {
+      const { address, scopeKey: _, ...parameters } = queryKey[1]
+      if (!address) throw new Error('address is required')
+      const transactionCount = await getTransactionCount(config, {
+        ...(parameters as GetTransactionCountParameters),
+        address,
+      })
+      return transactionCount ?? null
+    },
+    queryKey: getTransactionCountQueryKey(options),
+  } as const satisfies QueryOptions<
+    GetTransactionCountQueryFnData,
+    GetTransactionCountErrorType,
+    GetTransactionCountData,
+    GetTransactionCountQueryKey<config>
+  >
+}
+
+export type GetTransactionCountQueryFnData =
+  Evaluate<GetTransactionCountReturnType>
+
+export type GetTransactionCountData = GetTransactionCountQueryFnData
+
+export function getTransactionCountQueryKey<config extends Config>(
+  options: GetTransactionCountOptions<config> = {},
+) {
+  return ['transactionCount', filterQueryOptions(options)] as const
+}
+
+export type GetTransactionCountQueryKey<config extends Config> = ReturnType<
+  typeof getTransactionCountQueryKey<config>
+>

package/src/query/getWalletClient.ts

@@ -1,14 +1,14 @@
 import { type QueryOptions } from '@tanstack/query-core'
 
 import {
-  type GetWalletClientError,
+  type GetWalletClientErrorType,
   type GetWalletClientParameters,
   type GetWalletClientReturnType,
   getWalletClient,
 } from '../actions/getWalletClient.js'
-import type { Config } from '../createConfig.js'
+import { type Config } from '../createConfig.js'
+import type { ScopeKeyParameter } from '../types/properties.js'
 import type { Evaluate, ExactPartial } from '../types/utils.js'
-import type { ScopeKeyParameter } from './types.js'
 import { filterQueryOptions } from './utils.js'
 
 export type GetWalletClientOptions<
@@ -23,6 +23,7 @@ export function getWalletClientQueryOptions<
   chainId extends config['chains'][number]['id'],
 >(config: config, options: GetWalletClientOptions<config, chainId> = {}) {
   return {
+    gcTime: 0,
     async queryFn({ queryKey }) {
       const { connector } = options
       const { connectorUid: _, scopeKey: _s, ...parameters } = queryKey[1]
@@ -31,7 +32,7 @@ export function getWalletClientQueryOptions<
     queryKey: getWalletClientQueryKey(options),
   } as const satisfies QueryOptions<
     GetWalletClientQueryFnData<config, chainId>,
-    GetWalletClientError,
+    GetWalletClientErrorType,
     GetWalletClientData<config, chainId>,
     GetWalletClientQueryKey<config, chainId>
   >

package/src/query/infiniteReadContracts.ts

@@ -0,0 +1,129 @@
+import type { ContractFunctionParameters } from 'viem'
+import {
+  type ReadContractsErrorType,
+  type ReadContractsParameters,
+  type ReadContractsReturnType,
+  readContracts,
+} from '../actions/readContracts.js'
+import { type Config } from '../createConfig.js'
+import {
+  type ChainIdParameter,
+  type ScopeKeyParameter,
+} from '../types/properties.js'
+import { type Omit } from '../types/utils.js'
+import { type InfiniteQueryOptions } from './types.js'
+import { filterQueryOptions } from './utils.js'
+
+export type InfiniteReadContractsOptions<
+  contracts extends readonly unknown[],
+  allowFailure extends boolean,
+  pageParam,
+  config extends Config,
+> = {
+  cacheKey: string
+  contracts(
+    pageParam: pageParam,
+  ): ReadContractsParameters<contracts, allowFailure, config>['contracts']
+} & Omit<
+  ReadContractsParameters<contracts, allowFailure, config>,
+  'contracts'
+> &
+  ScopeKeyParameter
+
+export function infiniteReadContractsQueryOptions<
+  config extends Config,
+  const contracts extends readonly ContractFunctionParameters[],
+  allowFailure extends boolean = true,
+  pageParam = unknown,
+>(
+  config: config,
+  options: InfiniteReadContractsOptions<
+    contracts,
+    allowFailure,
+    pageParam,
+    config
+  > &
+    ChainIdParameter<config> &
+    RequiredPageParamsParameters<contracts, allowFailure, pageParam>,
+) {
+  return {
+    ...options.query,
+    async queryFn({ pageParam, queryKey }) {
+      const { contracts } = options
+      const { cacheKey: _, scopeKey: _s, ...parameters } = queryKey[1]
+      return (await readContracts(config, {
+        ...parameters,
+        contracts: contracts(
+          pageParam,
+        ) as readonly ContractFunctionParameters[],
+      })) as ReadContractsReturnType<contracts, allowFailure>
+    },
+    queryKey: infiniteReadContractsQueryKey(options),
+  } as const satisfies InfiniteQueryOptions<
+    InfiniteReadContractsQueryFnData<contracts, allowFailure>,
+    ReadContractsErrorType,
+    InfiniteReadContractsData<contracts, allowFailure>,
+    InfiniteReadContractsData<contracts, allowFailure>,
+    InfiniteReadContractsQueryKey<contracts, allowFailure, pageParam, config>,
+    pageParam
+  >
+}
+
+type RequiredPageParamsParameters<
+  contracts extends readonly unknown[],
+  allowFailure extends boolean,
+  pageParam,
+> = {
+  query: {
+    initialPageParam: pageParam
+    getNextPageParam(
+      lastPage: InfiniteReadContractsQueryFnData<contracts, allowFailure>,
+      allPages: InfiniteReadContractsQueryFnData<contracts, allowFailure>[],
+      lastPageParam: pageParam,
+      allPageParams: pageParam[],
+    ): pageParam | undefined | null
+  }
+}
+
+export type InfiniteReadContractsQueryFnData<
+  contracts extends readonly unknown[],
+  allowFailure extends boolean,
+> = ReadContractsReturnType<contracts, allowFailure>
+
+export type InfiniteReadContractsData<
+  contracts extends readonly unknown[],
+  allowFailure extends boolean,
+> = InfiniteReadContractsQueryFnData<contracts, allowFailure>
+
+export function infiniteReadContractsQueryKey<
+  config extends Config,
+  const contracts extends readonly unknown[],
+  allowFailure extends boolean,
+  pageParam,
+>(
+  options: InfiniteReadContractsOptions<
+    contracts,
+    allowFailure,
+    pageParam,
+    config
+  > &
+    ChainIdParameter<config> &
+    RequiredPageParamsParameters<contracts, allowFailure, pageParam>,
+) {
+  const { contracts: _, query: _q, ...parameters } = options
+  return ['infiniteReadContracts', filterQueryOptions(parameters)] as const
+}
+
+export type InfiniteReadContractsQueryKey<
+  contracts extends readonly unknown[],
+  allowFailure extends boolean,
+  pageParam,
+  config extends Config,
+> = ReturnType<
+  typeof infiniteReadContractsQueryKey<
+    config,
+    contracts,
+    allowFailure,
+    pageParam
+  >
+>

package/src/query/readContract.ts

@@ -6,14 +6,14 @@ import {
 } from 'viem'
 
 import {
-  type ReadContractError,
+  type ReadContractErrorType,
   type ReadContractParameters,
   type ReadContractReturnType,
   readContract,
 } from '../actions/readContract.js'
-import type { Config } from '../createConfig.js'
-import type { UnionPartial } from '../types/utils.js'
-import type { ScopeKeyParameter } from './types.js'
+import { type Config } from '../createConfig.js'
+import { type ScopeKeyParameter } from '../types/properties.js'
+import { type UnionPartial } from '../types/utils.js'
 import { filterQueryOptions } from './utils.js'
 
 export type ReadContractOptions<
@@ -30,10 +30,12 @@ export function readContractQueryOptions<
   functionName extends ContractFunctionName<abi, 'pure' | 'view'>,
   args extends ContractFunctionArgs<abi, 'pure' | 'view', functionName>,
 >(
-  config: Config,
+  config: config,
   options: ReadContractOptions<abi, functionName, args, config> = {} as any,
 ) {
   return {
+    // 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')
@@ -41,20 +43,20 @@ export function readContractQueryOptions<
       if (!address) throw new Error('address is required')
       if (!functionName) throw new Error('functionName is required')
       const args = parameters.args as readonly unknown[]
-      return (await readContract(config, {
+      return readContract(config, {
         abi,
         address,
         functionName,
         args,
         ...parameters,
-      })) as ReadContractData<abi, functionName, args>
+      }) as Promise<ReadContractData<abi, functionName, args>>
     },
     queryKey: readContractQueryKey(options),
   } as const satisfies QueryOptions<
     ReadContractQueryFnData<abi, functionName, args>,
-    ReadContractError,
+    ReadContractErrorType,
     ReadContractData<abi, functionName, args>,
-    ReadContractQueryKey<config, abi, functionName, args>
+    ReadContractQueryKey<abi, functionName, args, config>
   >
 }
 
@@ -71,18 +73,18 @@ export type ReadContractData<
 > = ReadContractQueryFnData<abi, functionName, args>
 
 export function readContractQueryKey<
+  config extends Config,
   const abi extends Abi | readonly unknown[],
   functionName extends ContractFunctionName<abi, 'pure' | 'view'>,
   args extends ContractFunctionArgs<abi, 'pure' | 'view', functionName>,
-  config extends Config,
 >(options: ReadContractOptions<abi, functionName, args, config> = {} as any) {
   const { abi: _, ...rest } = options
   return ['readContract', filterQueryOptions(rest)] as const
 }
 
 export type ReadContractQueryKey<
-  config extends Config,
   abi extends Abi | readonly unknown[],
   functionName extends ContractFunctionName<abi, 'pure' | 'view'>,
   args extends ContractFunctionArgs<abi, 'pure' | 'view', functionName>,
-> = ReturnType<typeof readContractQueryKey<abi, functionName, args, config>>
+  config extends Config,
+> = ReturnType<typeof readContractQueryKey<config, abi, functionName, args>>

package/src/query/readContracts.ts

@@ -5,20 +5,20 @@ import {
 } from 'viem'
 
 import {
-  type ReadContractsError,
+  type ReadContractsErrorType,
   type ReadContractsReturnType,
   readContracts,
 } from '../actions/readContracts.js'
-import type { Config } from '../createConfig.js'
-import type { ChainIdParameter } from '../types/properties.js'
+import { type Config } from '../createConfig.js'
+import { type ChainIdParameter } from '../types/properties.js'
+import type { ScopeKeyParameter } from '../types/properties.js'
 import type { ExactPartial } from '../types/utils.js'
-import type { ScopeKeyParameter } from './types.js'
 import { filterQueryOptions } from './utils.js'
 
 export type ReadContractsOptions<
-  config extends Config,
   contracts extends readonly unknown[],
   allowFailure extends boolean,
+  config extends Config,
 > = ExactPartial<
   viem_MulticallParameters<
     contracts,
@@ -33,8 +33,8 @@ export function readContractsQueryOptions<
   const contracts extends readonly unknown[],
   allowFailure extends boolean = true,
 >(
-  config: Config,
-  options: ReadContractsOptions<config, contracts, allowFailure> &
+  config: config,
+  options: ReadContractsOptions<contracts, allowFailure, config> &
     ChainIdParameter<config> = {},
 ) {
   return {
@@ -47,17 +47,17 @@ export function readContractsQueryOptions<
         contracts.push({ ...contract, abi })
       }
       const { scopeKey: _, ...parameters } = queryKey[1]
-      return (await readContracts(config, {
+      return readContracts(config, {
         ...parameters,
         contracts,
-      })) as ReadContractsData<contracts, allowFailure>
+      }) as Promise<ReadContractsReturnType<contracts, allowFailure>>
     },
-    queryKey: readContractsQueryKey(options as any),
+    queryKey: readContractsQueryKey(options),
   } as const satisfies QueryOptions<
     ReadContractsQueryFnData<contracts, allowFailure>,
-    ReadContractsError,
+    ReadContractsErrorType,
     ReadContractsData<contracts, allowFailure>,
-    ReadContractsQueryKey<config, contracts, allowFailure>
+    ReadContractsQueryKey<contracts, allowFailure, config>
   >
 }
 
@@ -76,14 +76,14 @@ export function readContractsQueryKey<
   const contracts extends readonly unknown[],
   allowFailure extends boolean,
 >(
-  options: ReadContractsOptions<config, contracts, allowFailure> &
+  options: ReadContractsOptions<contracts, allowFailure, config> &
     ChainIdParameter<config> = {},
 ) {
   const contracts = []
   for (const contract of (options.contracts ??
-    []) as ContractFunctionParameters[]) {
+    []) as (ContractFunctionParameters & { chainId: number })[]) {
     const { abi: _, ...rest } = contract
-    contracts.push({ ...rest, chainId: options.chainId })
+    contracts.push({ ...rest, chainId: rest.chainId ?? options.chainId })
   }
   return [
     'readContracts',
@@ -92,7 +92,7 @@ export function readContractsQueryKey<
 }
 
 export type ReadContractsQueryKey<
-  config extends Config,
   contracts extends readonly unknown[],
   allowFailure extends boolean,
+  config extends Config,
 > = ReturnType<typeof readContractsQueryKey<config, contracts, allowFailure>>

package/src/query/reconnect.ts

@@ -1,13 +1,13 @@
 import type { MutationOptions } from '@tanstack/query-core'
 
 import {
-  type ReconnectError,
+  type ReconnectErrorType,
   type ReconnectParameters,
   type ReconnectReturnType,
   reconnect,
 } from '../actions/reconnect.js'
-import type { Config } from '../createConfig.js'
-import type { Evaluate } from '../types/utils.js'
+import { type Config } from '../createConfig.js'
+import { type Evaluate } from '../types/utils.js'
 import type { Mutate, MutateAsync } from './types.js'
 
 export function reconnectMutationOptions(config: Config) {
@@ -18,7 +18,7 @@ export function reconnectMutationOptions(config: Config) {
     mutationKey: ['reconnect'],
   } as const satisfies MutationOptions<
     ReconnectData,
-    ReconnectError,
+    ReconnectErrorType,
     ReconnectVariables
   >
 }
@@ -29,14 +29,14 @@ export type ReconnectVariables = ReconnectParameters | undefined
 
 export type ReconnectMutate<context = unknown> = Mutate<
   ReconnectData,
-  ReconnectError,
+  ReconnectErrorType,
   ReconnectVariables,
   context
 >
 
 export type ReconnectMutateAsync<context = unknown> = MutateAsync<
   ReconnectData,
-  ReconnectError,
+  ReconnectErrorType,
   ReconnectVariables,
   context
 >

package/src/query/sendTransaction.ts

@@ -1,13 +1,13 @@
 import type { MutateOptions, MutationOptions } from '@tanstack/query-core'
 
 import {
-  type SendTransactionError,
+  type SendTransactionErrorType,
   type SendTransactionParameters,
   type SendTransactionReturnType,
   sendTransaction,
 } from '../actions/sendTransaction.js'
 import { type Config } from '../createConfig.js'
-import type { Evaluate } from '../types/utils.js'
+import { type Evaluate } from '../types/utils.js'
 
 export function sendTransactionMutationOptions<config extends Config>(
   config: config,
@@ -19,7 +19,7 @@ export function sendTransactionMutationOptions<config extends Config>(
     mutationKey: ['sendTransaction'],
   } as const satisfies MutationOptions<
     SendTransactionData,
-    SendTransactionError,
+    SendTransactionErrorType,
     SendTransactionVariables<config, config['chains'][number]['id']>
   >
 }
@@ -39,7 +39,7 @@ export type SendTransactionMutate<config extends Config, context = unknown> = <
     | Evaluate<
         MutateOptions<
           SendTransactionData,
-          SendTransactionError,
+          SendTransactionErrorType,
           Evaluate<SendTransactionVariables<config, chainId>>,
           context
         >
@@ -56,7 +56,7 @@ export type SendTransactionMutateAsync<
     | Evaluate<
         MutateOptions<
           SendTransactionData,
-          SendTransactionError,
+          SendTransactionErrorType,
           Evaluate<SendTransactionVariables<config, chainId>>,
           context
         >

package/src/query/signMessage.ts

@@ -1,7 +1,7 @@
 import type { MutationOptions } from '@tanstack/query-core'
 
 import {
-  type SignMessageError,
+  type SignMessageErrorType,
   type SignMessageParameters,
   type SignMessageReturnType,
   signMessage,
@@ -18,7 +18,7 @@ export function signMessageMutationOptions(config: Config) {
     mutationKey: ['signMessage'],
   } as const satisfies MutationOptions<
     SignMessageData,
-    SignMessageError,
+    SignMessageErrorType,
     SignMessageVariables
   >
 }
@@ -29,14 +29,14 @@ export type SignMessageVariables = Evaluate<SignMessageParameters>
 
 export type SignMessageMutate<context = unknown> = Mutate<
   SignMessageData,
-  SignMessageError,
+  SignMessageErrorType,
   SignMessageVariables,
   context
 >
 
 export type SignMessageMutateAsync<context = unknown> = MutateAsync<
   SignMessageData,
-  SignMessageError,
+  SignMessageErrorType,
   SignMessageVariables,
   context
 >