@wagmi/core 1.4.1 → 2.0.0-alpha.1

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,75 @@
+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,
+  ///
+  primaryTypes = typedData extends TypedData ? keyof typedData : string,
+> = SignTypedDataParameters<typedData, primaryType, primaryTypes>
+
+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,
+          // use `primaryType` to make sure it's not union of all possible primary types
+          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,
+          // use `primaryType` to make sure it's not union of all possible primary types
+          primaryType
+        >,
+        context
+      >
+    | undefined,
+) => Promise<SignTypedDataData>

package/src/query/simulateContract.ts

@@ -0,0 +1,128 @@
+import { type QueryOptions } from '@tanstack/query-core'
+import type { Abi, ContractFunctionArgs, ContractFunctionName } from 'viem'
+
+import {
+  type SimulateContractError,
+  type SimulateContractParameters,
+  type SimulateContractReturnType,
+  simulateContract,
+} from '../actions/simulateContract.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 SimulateContractOptions<
+  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,
+> = UnionPartial<
+  SimulateContractParameters<abi, functionName, args, config, chainId>
+> &
+  ScopeKeyParameter
+
+export function simulateContractQueryOptions<
+  const 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,
+>(
+  config: config,
+  options: SimulateContractOptions<
+    abi,
+    functionName,
+    args,
+    config,
+    chainId
+  > = {} as any,
+) {
+  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')
+      return simulateContract(config, { abi, connector, ...parameters } as any)
+    },
+    queryKey: simulateContractQueryKey(options),
+  } as const satisfies QueryOptions<
+    SimulateContractQueryFnData<abi, functionName, args, config, chainId>,
+    SimulateContractError,
+    SimulateContractData<abi, functionName, args, config, chainId>,
+    SimulateContractQueryKey<abi, functionName, args, config, chainId>
+  >
+}
+
+export type SimulateContractQueryFnData<
+  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,
+> = SimulateContractReturnType<abi, functionName, args, config, chainId>
+
+export type SimulateContractData<
+  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,
+> = SimulateContractQueryFnData<abi, functionName, args, config, chainId>
+
+export function simulateContractQueryKey<
+  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,
+>(
+  options: SimulateContractOptions<
+    abi,
+    functionName,
+    args,
+    config,
+    chainId
+  > = {} as any,
+) {
+  const { abi: _, connector: _c, ...rest } = options
+  return ['simulateContract', filterQueryOptions(rest)] as const
+}
+
+export type SimulateContractQueryKey<
+  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,
+> = ReturnType<
+  typeof simulateContractQueryKey<abi, functionName, args, config, chainId>
+>

package/src/query/switchAccount.ts

@@ -0,0 +1,52 @@
+import type { MutationOptions } from '@tanstack/query-core'
+
+import {
+  type SwitchAccountError,
+  type SwitchAccountParameters,
+  type SwitchAccountReturnType,
+  switchAccount,
+} from '../actions/switchAccount.js'
+import { type Config } from '../createConfig.js'
+import type { Evaluate } from '../types/utils.js'
+import type { Mutate, MutateAsync } from './types.js'
+
+export function switchAccountMutationOptions<config extends Config>(
+  config: config,
+) {
+  return {
+    mutationFn(variables) {
+      return switchAccount(config, variables)
+    },
+    mutationKey: ['switchAccount'],
+  } as const satisfies MutationOptions<
+    SwitchAccountData<config>,
+    SwitchAccountError,
+    SwitchAccountVariables
+  >
+}
+
+export type SwitchAccountData<config extends Config> = Evaluate<
+  SwitchAccountReturnType<config>
+>
+
+export type SwitchAccountVariables = Evaluate<SwitchAccountParameters>
+
+export type SwitchAccountMutate<
+  config extends Config,
+  context = unknown,
+> = Mutate<
+  SwitchAccountData<config>,
+  SwitchAccountError,
+  SwitchAccountVariables,
+  context
+>
+
+export type SwitchAccountMutateAsync<
+  config extends Config,
+  context = unknown,
+> = MutateAsync<
+  SwitchAccountData<config>,
+  SwitchAccountError,
+  SwitchAccountVariables,
+  context
+>

package/src/query/switchChain.ts

@@ -0,0 +1,67 @@
+import type { MutateOptions, MutationOptions } from '@tanstack/query-core'
+
+import {
+  type SwitchChainError,
+  type SwitchChainParameters,
+  type SwitchChainReturnType,
+  switchChain,
+} from '../actions/switchChain.js'
+import { type Config } from '../createConfig.js'
+import type { Evaluate } from '../types/utils.js'
+
+export function switchChainMutationOptions<config extends Config>(
+  config: config,
+) {
+  return {
+    mutationFn(variables) {
+      return switchChain(config, variables)
+    },
+    mutationKey: ['switchChain'],
+  } as const satisfies MutationOptions<
+    SwitchChainData<config, config['chains'][number]['id']>,
+    SwitchChainError,
+    SwitchChainVariables<config, config['chains'][number]['id']>
+  >
+}
+
+export type SwitchChainData<
+  config extends Config,
+  chainId extends config['chains'][number]['id'],
+> = Evaluate<SwitchChainReturnType<config, chainId>>
+
+export type SwitchChainVariables<
+  config extends Config,
+  chainId extends config['chains'][number]['id'],
+> = Evaluate<SwitchChainParameters<config, chainId>>
+
+export type SwitchChainMutate<config extends Config, context = unknown> = <
+  chainId extends config['chains'][number]['id'],
+>(
+  variables: SwitchChainVariables<config, chainId>,
+  options?:
+    | Evaluate<
+        MutateOptions<
+          SwitchChainData<config, chainId>,
+          SwitchChainError,
+          Evaluate<SwitchChainVariables<config, chainId>>,
+          context
+        >
+      >
+    | undefined,
+) => void
+
+export type SwitchChainMutateAsync<config extends Config, context = unknown> = <
+  chainId extends config['chains'][number]['id'],
+>(
+  variables: SwitchChainVariables<config, chainId>,
+  options?:
+    | Evaluate<
+        MutateOptions<
+          SwitchChainData<config, chainId>,
+          SwitchChainError,
+          Evaluate<SwitchChainVariables<config, chainId>>,
+          context
+        >
+      >
+    | undefined,
+) => Promise<SwitchChainData<config, chainId>>

package/src/query/types.ts

@@ -0,0 +1,52 @@
+import type { Evaluate } from '../types/utils.js'
+
+export type ScopeKeyParameter = { scopeKey?: string | undefined }
+
+type MutateFn<
+  data = unknown,
+  error = unknown,
+  variables = void,
+  context = unknown,
+> = undefined extends variables
+  ? (
+      variables?: variables,
+      options?:
+        | Evaluate<
+            import('@tanstack/query-core').MutateOptions<
+              data,
+              error,
+              variables,
+              context
+            >
+          >
+        | undefined,
+    ) => Promise<data>
+  : (
+      variables: variables,
+      options?:
+        | Evaluate<
+            import('@tanstack/query-core').MutateOptions<
+              data,
+              error,
+              variables,
+              context
+            >
+          >
+        | undefined,
+    ) => Promise<data>
+
+export type Mutate<
+  data = unknown,
+  error = unknown,
+  variables = void,
+  context = unknown,
+> = (
+  ...args: Parameters<MutateFn<data, error, Evaluate<variables>, context>>
+) => void
+
+export type MutateAsync<
+  data = unknown,
+  error = unknown,
+  variables = void,
+  context = unknown,
+> = MutateFn<data, error, Evaluate<variables>, context>

package/src/query/utils.ts

@@ -0,0 +1,54 @@
+import type { QueryKey } from '@tanstack/query-core'
+
+export function hashFn(queryKey: QueryKey): string {
+  return JSON.stringify(queryKey, (_, value) => {
+    if (isPlainObject(value))
+      return Object.keys(value)
+        .sort()
+        .reduce((result, key) => {
+          result[key] = value[key]
+          return result
+        }, {} as any)
+    if (typeof value === 'bigint') return value.toString()
+    return value
+  })
+}
+
+function isPlainObject(o: any): o is Object {
+  if (!hasObjectPrototype(o)) {
+    return false
+  }
+
+  // If has modified constructor
+  const ctor = o.constructor
+  if (typeof ctor === 'undefined') return true
+
+  // If has modified prototype
+  const prot = ctor.prototype
+  if (!hasObjectPrototype(prot)) return false
+
+  // If constructor does not have an Object-specific method
+  // biome-ignore lint/suspicious/noPrototypeBuiltins: <explanation>
+  if (!prot.hasOwnProperty('isPrototypeOf')) return false
+
+  // Most likely a plain Object
+  return true
+}
+
+function hasObjectPrototype(o: any): boolean {
+  return Object.prototype.toString.call(o) === '[object Object]'
+}
+
+export function filterQueryOptions<type extends Record<string, unknown>>(
+  options: type,
+): type {
+  // destructuring is super fast
+  // biome-ignore format: no formatting
+  const {
+    // biome-ignore lint/correctness/noUnusedVariables: remove properties
+    config, connector, query,
+    ...rest
+  } = options
+
+  return rest as type
+}

package/src/query/waitForTransactionReceipt.ts

@@ -0,0 +1,71 @@
+import { type QueryOptions } from '@tanstack/query-core'
+
+import {
+  type WaitForTransactionReceiptError,
+  type WaitForTransactionReceiptParameters,
+  type WaitForTransactionReceiptReturnType,
+  waitForTransactionReceipt,
+} from '../actions/waitForTransactionReceipt.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 WaitForTransactionReceiptOptions<
+  config extends Config,
+  chainId extends config['chains'][number]['id'],
+> = Evaluate<
+  ExactPartial<WaitForTransactionReceiptParameters<config, chainId>> &
+    ScopeKeyParameter
+>
+
+export function waitForTransactionReceiptQueryOptions<
+  config extends Config,
+  chainId extends config['chains'][number]['id'],
+>(
+  config: Config,
+  options: WaitForTransactionReceiptOptions<config, chainId> = {},
+) {
+  return {
+    async queryFn({ queryKey }) {
+      const { hash, ...parameters } = queryKey[1]
+      if (!hash) throw new Error('hash is required')
+      return waitForTransactionReceipt(config, {
+        ...parameters,
+        onReplaced: options.onReplaced,
+        hash,
+      }) as unknown as Promise<
+        WaitForTransactionReceiptReturnType<config, chainId>
+      >
+    },
+    queryKey: waitForTransactionReceiptQueryKey(options),
+  } as const satisfies QueryOptions<
+    WaitForTransactionReceiptQueryFnData<config, chainId>,
+    WaitForTransactionReceiptError,
+    WaitForTransactionReceiptData<config, chainId>,
+    WaitForTransactionReceiptQueryKey<config, chainId>
+  >
+}
+
+export type WaitForTransactionReceiptQueryFnData<
+  config extends Config,
+  chainId extends config['chains'][number]['id'],
+> = WaitForTransactionReceiptReturnType<config, chainId>
+
+export type WaitForTransactionReceiptData<
+  config extends Config,
+  chainId extends config['chains'][number]['id'],
+> = WaitForTransactionReceiptQueryFnData<config, chainId>
+
+export function waitForTransactionReceiptQueryKey<
+  config extends Config,
+  chainId extends config['chains'][number]['id'],
+>(options: WaitForTransactionReceiptOptions<config, chainId> = {}) {
+  const { onReplaced: _, ...rest } = options
+  return ['waitForTransactionReceipt', filterQueryOptions(rest)] as const
+}
+
+export type WaitForTransactionReceiptQueryKey<
+  config extends Config,
+  chainId extends config['chains'][number]['id'],
+> = ReturnType<typeof waitForTransactionReceiptQueryKey<config, chainId>>