@wagmi/core 1.4.1 → 2.0.0

package/src/query/getEnsName.ts

@@ -0,0 +1,49 @@
+import { type QueryOptions } from '@tanstack/query-core'
+
+import {
+  type GetEnsNameError,
+  type GetEnsNameParameters,
+  type GetEnsNameReturnType,
+  getEnsName,
+} from '../actions/getEnsName.js'
+import type { Config } from '../createConfig.js'
+import type { Evaluate, ExactPartial } from '../types/utils.js'
+import type { ScopeKeyParameter } from './types.js'
+import { filterQueryOptions } from './utils.js'
+
+export type GetEnsNameOptions<config extends Config> = Evaluate<
+  ExactPartial<GetEnsNameParameters<config>> & ScopeKeyParameter
+>
+
+export function getEnsNameQueryOptions<config extends Config>(
+  config: config,
+  options: GetEnsNameOptions<config> = {},
+) {
+  return {
+    async queryFn({ queryKey }) {
+      const { address, scopeKey: _, ...parameters } = queryKey[1]
+      if (!address) throw new Error('address is required')
+      return getEnsName(config, { ...parameters, address })
+    },
+    queryKey: getEnsNameQueryKey(options),
+  } as const satisfies QueryOptions<
+    GetEnsNameQueryFnData,
+    GetEnsNameError,
+    GetEnsNameData,
+    GetEnsNameQueryKey<config>
+  >
+}
+
+export type GetEnsNameQueryFnData = GetEnsNameReturnType
+
+export type GetEnsNameData = GetEnsNameQueryFnData
+
+export function getEnsNameQueryKey<config extends Config>(
+  options: GetEnsNameOptions<config> = {},
+) {
+  return ['ensName', filterQueryOptions(options)] as const
+}
+
+export type GetEnsNameQueryKey<config extends Config> = ReturnType<
+  typeof getEnsNameQueryKey<config>
+>

package/src/query/getEnsResolver.ts

@@ -0,0 +1,49 @@
+import { type QueryOptions } from '@tanstack/query-core'
+
+import {
+  type GetEnsResolverError,
+  type GetEnsResolverParameters,
+  type GetEnsResolverReturnType,
+  getEnsResolver,
+} from '../actions/getEnsResolver.js'
+import type { Config } from '../createConfig.js'
+import type { Evaluate, ExactPartial } from '../types/utils.js'
+import type { ScopeKeyParameter } from './types.js'
+import { filterQueryOptions } from './utils.js'
+
+export type GetEnsResolverOptions<config extends Config> = Evaluate<
+  ExactPartial<GetEnsResolverParameters<config>> & ScopeKeyParameter
+>
+
+export function getEnsResolverQueryOptions<config extends Config>(
+  config: config,
+  options: GetEnsResolverOptions<config> = {},
+) {
+  return {
+    async queryFn({ queryKey }) {
+      const { name, scopeKey: _, ...parameters } = queryKey[1]
+      if (!name) throw new Error('name is required')
+      return getEnsResolver(config, { ...parameters, name })
+    },
+    queryKey: getEnsResolverQueryKey(options),
+  } as const satisfies QueryOptions<
+    GetEnsResolverQueryFnData,
+    GetEnsResolverError,
+    GetEnsResolverData,
+    GetEnsResolverQueryKey<config>
+  >
+}
+
+export type GetEnsResolverQueryFnData = GetEnsResolverReturnType
+
+export type GetEnsResolverData = GetEnsResolverQueryFnData
+
+export function getEnsResolverQueryKey<config extends Config>(
+  options: GetEnsResolverOptions<config> = {},
+) {
+  return ['ensResolver', filterQueryOptions(options)] as const
+}
+
+export type GetEnsResolverQueryKey<config extends Config> = ReturnType<
+  typeof getEnsResolverQueryKey<config>
+>

package/src/query/getToken.ts

@@ -0,0 +1,49 @@
+import { type QueryOptions } from '@tanstack/query-core'
+
+import {
+  type GetTokenError,
+  type GetTokenParameters,
+  type GetTokenReturnType,
+  getToken,
+} from '../actions/getToken.js'
+import type { Config } from '../createConfig.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<
+  ExactPartial<GetTokenParameters<config>> & ScopeKeyParameter
+>
+
+export function getTokenQueryOptions<config extends Config>(
+  config: config,
+  options: GetTokenOptions<config> = {},
+) {
+  return {
+    async queryFn({ queryKey }) {
+      const { address, scopeKey: _, ...parameters } = queryKey[1]
+      if (!address) throw new Error('address is required')
+      return getToken(config, { ...parameters, address })
+    },
+    queryKey: getTokenQueryKey(options),
+  } as const satisfies QueryOptions<
+    GetTokenQueryFnData,
+    GetTokenError,
+    GetTokenData,
+    GetTokenQueryKey<config>
+  >
+}
+
+export type GetTokenQueryFnData = GetTokenReturnType
+
+export type GetTokenData = GetTokenQueryFnData
+
+export function getTokenQueryKey<config extends Config>(
+  options: GetTokenOptions<config> = {},
+) {
+  return ['token', filterQueryOptions(options)] as const
+}
+
+export type GetTokenQueryKey<config extends Config> = ReturnType<
+  typeof getTokenQueryKey<config>
+>

package/src/query/getTransaction.ts

@@ -0,0 +1,75 @@
+import { type QueryOptions } from '@tanstack/query-core'
+
+import {
+  type GetTransactionError,
+  type GetTransactionParameters,
+  type GetTransactionReturnType,
+  getTransaction,
+} from '../actions/getTransaction.js'
+import type { Config } from '../createConfig.js'
+import type { Evaluate, ExactPartial } from '../types/utils.js'
+import type { ScopeKeyParameter } from './types.js'
+import { filterQueryOptions } from './utils.js'
+
+export type GetTransactionOptions<
+  config extends Config,
+  chainId extends config['chains'][number]['id'],
+> = Evaluate<
+  ExactPartial<GetTransactionParameters<config, chainId>> & ScopeKeyParameter
+>
+
+export function getTransactionQueryOptions<
+  config extends Config,
+  chainId extends config['chains'][number]['id'],
+>(config: config, options: GetTransactionOptions<config, chainId> = {}) {
+  return {
+    async queryFn({ queryKey }) {
+      const {
+        blockHash,
+        blockNumber,
+        blockTag,
+        hash,
+        index,
+        scopeKey: _,
+      } = 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',
+        )
+      return getTransaction(
+        config,
+        queryKey[1] as GetTransactionParameters,
+      ) as unknown as Promise<GetTransactionQueryFnData<config, chainId>>
+    },
+    queryKey: getTransactionQueryKey(options),
+  } as const satisfies QueryOptions<
+    GetTransactionQueryFnData<config, chainId>,
+    GetTransactionError,
+    GetTransactionData<config, chainId>,
+    GetTransactionQueryKey<config, chainId>
+  >
+}
+
+export type GetTransactionQueryFnData<
+  config extends Config,
+  chainId extends config['chains'][number]['id'],
+> = GetTransactionReturnType<config, chainId>
+
+export type GetTransactionData<
+  config extends Config,
+  chainId extends config['chains'][number]['id'],
+> = GetTransactionQueryFnData<config, chainId>
+
+export function getTransactionQueryKey<
+  config extends Config,
+  chainId extends config['chains'][number]['id'],
+>(options: GetTransactionOptions<config, chainId> = {}) {
+  return ['transaction', filterQueryOptions(options)] as const
+}
+
+export type GetTransactionQueryKey<
+  config extends Config,
+  chainId extends config['chains'][number]['id'],
+> = ReturnType<typeof getTransactionQueryKey<config, chainId>>

package/src/query/getWalletClient.ts

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

package/src/query/readContract.ts

@@ -0,0 +1,88 @@
+import { type QueryOptions } from '@tanstack/query-core'
+import {
+  type Abi,
+  type ContractFunctionArgs,
+  type ContractFunctionName,
+} from 'viem'
+
+import {
+  type ReadContractError,
+  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 { filterQueryOptions } 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,
+> = UnionPartial<ReadContractParameters<abi, functionName, args, config>> &
+  ScopeKeyParameter
+
+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>,
+>(
+  config: Config,
+  options: ReadContractOptions<abi, functionName, args, config> = {} as any,
+) {
+  return {
+    async queryFn({ queryKey }) {
+      const abi = options.abi as Abi
+      if (!abi) throw new Error('abi is required')
+      const { address, functionName, scopeKey: _, ...parameters } = queryKey[1]
+      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, {
+        abi,
+        address,
+        functionName,
+        args,
+        ...parameters,
+      })) as ReadContractData<abi, functionName, args>
+    },
+    queryKey: readContractQueryKey(options),
+  } as const satisfies QueryOptions<
+    ReadContractQueryFnData<abi, functionName, args>,
+    ReadContractError,
+    ReadContractData<abi, functionName, args>,
+    ReadContractQueryKey<config, abi, functionName, args>
+  >
+}
+
+export type ReadContractQueryFnData<
+  abi extends Abi | readonly unknown[],
+  functionName extends ContractFunctionName<abi, 'pure' | 'view'>,
+  args extends ContractFunctionArgs<abi, 'pure' | 'view', functionName>,
+> = ReadContractReturnType<abi, functionName, args>
+
+export type ReadContractData<
+  abi extends Abi | readonly unknown[],
+  functionName extends ContractFunctionName<abi, 'pure' | 'view'>,
+  args extends ContractFunctionArgs<abi, 'pure' | 'view', functionName>,
+> = ReadContractQueryFnData<abi, functionName, args>
+
+export function readContractQueryKey<
+  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>>

package/src/query/readContracts.ts

@@ -0,0 +1,98 @@
+import { type QueryOptions } from '@tanstack/query-core'
+import {
+  type ContractFunctionParameters,
+  type MulticallParameters as viem_MulticallParameters,
+} from 'viem'
+
+import {
+  type ReadContractsError,
+  type ReadContractsReturnType,
+  readContracts,
+} from '../actions/readContracts.js'
+import type { Config } from '../createConfig.js'
+import type { ChainIdParameter } 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,
+> = ExactPartial<
+  viem_MulticallParameters<
+    contracts,
+    allowFailure,
+    { optional: true; properties: ChainIdParameter<config> }
+  >
+> &
+  ScopeKeyParameter
+
+export function readContractsQueryOptions<
+  config extends Config,
+  const contracts extends readonly unknown[],
+  allowFailure extends boolean = true,
+>(
+  config: Config,
+  options: ReadContractsOptions<config, contracts, allowFailure> &
+    ChainIdParameter<config> = {},
+) {
+  return {
+    async queryFn({ queryKey }) {
+      const contracts: ContractFunctionParameters[] = []
+      const length = queryKey[1].contracts.length
+      for (let i = 0; i < length; i++) {
+        const contract = queryKey[1].contracts[i]!
+        const abi = (options.contracts?.[i] as ContractFunctionParameters).abi
+        contracts.push({ ...contract, abi })
+      }
+      const { scopeKey: _, ...parameters } = queryKey[1]
+      return (await readContracts(config, {
+        ...parameters,
+        contracts,
+      })) as ReadContractsData<contracts, allowFailure>
+    },
+    queryKey: readContractsQueryKey(options as any),
+  } as const satisfies QueryOptions<
+    ReadContractsQueryFnData<contracts, allowFailure>,
+    ReadContractsError,
+    ReadContractsData<contracts, allowFailure>,
+    ReadContractsQueryKey<config, contracts, allowFailure>
+  >
+}
+
+export type ReadContractsQueryFnData<
+  contracts extends readonly unknown[],
+  allowFailure extends boolean,
+> = ReadContractsReturnType<contracts, allowFailure>
+
+export type ReadContractsData<
+  contracts extends readonly unknown[],
+  allowFailure extends boolean,
+> = ReadContractsQueryFnData<contracts, allowFailure>
+
+export function readContractsQueryKey<
+  config extends Config,
+  const contracts extends readonly unknown[],
+  allowFailure extends boolean,
+>(
+  options: ReadContractsOptions<config, contracts, allowFailure> &
+    ChainIdParameter<config> = {},
+) {
+  const contracts = []
+  for (const contract of (options.contracts ??
+    []) as ContractFunctionParameters[]) {
+    const { abi: _, ...rest } = contract
+    contracts.push({ ...rest, chainId: options.chainId })
+  }
+  return [
+    'readContracts',
+    filterQueryOptions({ ...options, contracts }),
+  ] as const
+}
+
+export type ReadContractsQueryKey<
+  config extends Config,
+  contracts extends readonly unknown[],
+  allowFailure extends boolean,
+> = ReturnType<typeof readContractsQueryKey<config, contracts, allowFailure>>

package/src/query/reconnect.ts

@@ -0,0 +1,42 @@
+import type { MutationOptions } from '@tanstack/query-core'
+
+import {
+  type ReconnectError,
+  type ReconnectParameters,
+  type ReconnectReturnType,
+  reconnect,
+} from '../actions/reconnect.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) {
+  return {
+    mutationFn(variables) {
+      return reconnect(config, variables)
+    },
+    mutationKey: ['reconnect'],
+  } as const satisfies MutationOptions<
+    ReconnectData,
+    ReconnectError,
+    ReconnectVariables
+  >
+}
+
+export type ReconnectData = Evaluate<ReconnectReturnType>
+
+export type ReconnectVariables = ReconnectParameters | undefined
+
+export type ReconnectMutate<context = unknown> = Mutate<
+  ReconnectData,
+  ReconnectError,
+  ReconnectVariables,
+  context
+>
+
+export type ReconnectMutateAsync<context = unknown> = MutateAsync<
+  ReconnectData,
+  ReconnectError,
+  ReconnectVariables,
+  context
+>

package/src/query/sendTransaction.ts

@@ -0,0 +1,65 @@
+import type { MutateOptions, MutationOptions } from '@tanstack/query-core'
+
+import {
+  type SendTransactionError,
+  type SendTransactionParameters,
+  type SendTransactionReturnType,
+  sendTransaction,
+} from '../actions/sendTransaction.js'
+import { type Config } from '../createConfig.js'
+import type { Evaluate } from '../types/utils.js'
+
+export function sendTransactionMutationOptions<config extends Config>(
+  config: config,
+) {
+  return {
+    mutationFn(variables) {
+      return sendTransaction(config, variables)
+    },
+    mutationKey: ['sendTransaction'],
+  } as const satisfies MutationOptions<
+    SendTransactionData,
+    SendTransactionError,
+    SendTransactionVariables<config, config['chains'][number]['id']>
+  >
+}
+
+export type SendTransactionData = Evaluate<SendTransactionReturnType>
+
+export type SendTransactionVariables<
+  config extends Config,
+  chainId extends config['chains'][number]['id'],
+> = SendTransactionParameters<config, chainId>
+
+export type SendTransactionMutate<config extends Config, context = unknown> = <
+  chainId extends config['chains'][number]['id'],
+>(
+  variables: SendTransactionVariables<config, chainId>,
+  options?:
+    | Evaluate<
+        MutateOptions<
+          SendTransactionData,
+          SendTransactionError,
+          Evaluate<SendTransactionVariables<config, chainId>>,
+          context
+        >
+      >
+    | undefined,
+) => void
+
+export type SendTransactionMutateAsync<
+  config extends Config,
+  context = unknown,
+> = <chainId extends config['chains'][number]['id']>(
+  variables: SendTransactionVariables<config, chainId>,
+  options?:
+    | Evaluate<
+        MutateOptions<
+          SendTransactionData,
+          SendTransactionError,
+          Evaluate<SendTransactionVariables<config, chainId>>,
+          context
+        >
+      >
+    | undefined,
+) => Promise<SendTransactionData>

package/src/query/signMessage.ts

@@ -0,0 +1,42 @@
+import type { MutationOptions } from '@tanstack/query-core'
+
+import {
+  type SignMessageError,
+  type SignMessageParameters,
+  type SignMessageReturnType,
+  signMessage,
+} from '../actions/signMessage.js'
+import { type Config } from '../createConfig.js'
+import { type Evaluate } from '../types/utils.js'
+import { type Mutate, type MutateAsync } from './types.js'
+
+export function signMessageMutationOptions(config: Config) {
+  return {
+    mutationFn(variables) {
+      return signMessage(config, variables)
+    },
+    mutationKey: ['signMessage'],
+  } as const satisfies MutationOptions<
+    SignMessageData,
+    SignMessageError,
+    SignMessageVariables
+  >
+}
+
+export type SignMessageData = SignMessageReturnType
+
+export type SignMessageVariables = Evaluate<SignMessageParameters>
+
+export type SignMessageMutate<context = unknown> = Mutate<
+  SignMessageData,
+  SignMessageError,
+  SignMessageVariables,
+  context
+>
+
+export type SignMessageMutateAsync<context = unknown> = MutateAsync<
+  SignMessageData,
+  SignMessageError,
+  SignMessageVariables,
+  context
+>

package/src/query/signTypedData.ts

@@ -0,0 +1,63 @@
+import type { MutateOptions, MutationOptions } from '@tanstack/query-core'
+
+import type { TypedData } from 'viem'
+import {
+  type SignTypedDataError,
+  type SignTypedDataParameters,
+  type SignTypedDataReturnType,
+  signTypedData,
+} from '../actions/signTypedData.js'
+import { type Config } from '../createConfig.js'
+import type { Evaluate } from '../types/utils.js'
+
+export function signTypedDataMutationOptions<config extends Config>(
+  config: config,
+) {
+  return {
+    mutationFn(variables) {
+      return signTypedData(config, variables)
+    },
+    mutationKey: ['signTypedData'],
+  } as const satisfies MutationOptions<
+    SignTypedDataData,
+    SignTypedDataError,
+    SignTypedDataVariables
+  >
+}
+
+export type SignTypedDataData = Evaluate<SignTypedDataReturnType>
+
+export type SignTypedDataVariables<
+  typedData extends TypedData | Record<string, unknown> = TypedData,
+  primaryType extends keyof typedData | 'EIP712Domain' = keyof typedData,
+> = SignTypedDataParameters<typedData, primaryType>
+
+export type SignTypedDataMutate<context = unknown> = <
+  const typedData extends TypedData | Record<string, unknown>,
+  primaryType extends keyof typedData | 'EIP712Domain',
+>(
+  variables: SignTypedDataVariables<typedData, primaryType>,
+  options?:
+    | MutateOptions<
+        SignTypedDataData,
+        SignTypedDataError,
+        SignTypedDataVariables<typedData, primaryType>,
+        context
+      >
+    | undefined,
+) => void
+
+export type SignTypedDataMutateAsync<context = unknown> = <
+  const typedData extends TypedData | Record<string, unknown>,
+  primaryType extends keyof typedData | 'EIP712Domain',
+>(
+  variables: SignTypedDataVariables<typedData, primaryType>,
+  options?:
+    | MutateOptions<
+        SignTypedDataData,
+        SignTypedDataError,
+        SignTypedDataVariables<typedData, primaryType>,
+        context
+      >
+    | undefined,
+) => Promise<SignTypedDataData>