wagmi 1.4.1 → 2.0.0

package/src/hooks/usePublicClient.ts

@@ -0,0 +1,45 @@
+'use client'
+
+import {
+  type Config,
+  type GetPublicClientParameters,
+  type GetPublicClientReturnType,
+  type ResolvedRegister,
+  getPublicClient,
+  watchPublicClient,
+} from '@wagmi/core'
+import type { Evaluate } from '@wagmi/core/internal'
+import { useSyncExternalStoreWithSelector } from 'use-sync-external-store/shim/with-selector.js'
+
+import type { ConfigParameter } from '../types/properties.js'
+import { useConfig } from './useConfig.js'
+
+export type UsePublicClientParameters<
+  config extends Config = Config,
+  chainId extends config['chains'][number]['id'] = config['chains'][number]['id'],
+> = Evaluate<
+  GetPublicClientParameters<config, chainId> & ConfigParameter<config>
+>
+
+export type UsePublicClientReturnType<
+  config extends Config = Config,
+  chainId extends config['chains'][number]['id'] = config['chains'][number]['id'],
+> = GetPublicClientReturnType<config, chainId>
+
+/** https://alpha.wagmi.sh/react/api/hooks/usePublicClient */
+export function usePublicClient<
+  config extends Config = ResolvedRegister['config'],
+  chainId extends config['chains'][number]['id'] = config['chains'][number]['id'],
+>(
+  parameters: UsePublicClientParameters<config, chainId> = {},
+): UsePublicClientReturnType<config, chainId> {
+  const config = useConfig(parameters)
+
+  return useSyncExternalStoreWithSelector(
+    (onChange) => watchPublicClient(config, { onChange }),
+    () => getPublicClient(config, parameters),
+    () => getPublicClient(config, parameters),
+    (x) => x,
+    (a, b) => a.uid === b.uid,
+  ) as any
+}

package/src/hooks/useReconnect.ts

@@ -0,0 +1,67 @@
+'use client'
+
+import { useMutation } from '@tanstack/react-query'
+import { type Connector, type ReconnectError } from '@wagmi/core'
+import type { Evaluate } from '@wagmi/core/internal'
+import {
+  type ReconnectData,
+  type ReconnectMutate,
+  type ReconnectMutateAsync,
+  type ReconnectVariables,
+  reconnectMutationOptions,
+} from '@wagmi/core/query'
+
+import type { ConfigParameter } from '../types/properties.js'
+import type {
+  UseMutationParameters,
+  UseMutationReturnType,
+} from '../utils/query.js'
+import { useConfig } from './useConfig.js'
+
+export type UseReconnectParameters<context = unknown> = Evaluate<
+  ConfigParameter & {
+    mutation?:
+      | UseMutationParameters<
+          ReconnectData,
+          ReconnectError,
+          ReconnectVariables,
+          context
+        >
+      | undefined
+  }
+>
+
+export type UseReconnectReturnType<context = unknown> = Evaluate<
+  UseMutationReturnType<
+    ReconnectData,
+    ReconnectError,
+    ReconnectVariables,
+    context
+  > & {
+    connectors: readonly Connector[]
+    reconnect: ReconnectMutate<context>
+    reconnectAsync: ReconnectMutateAsync<context>
+  }
+>
+
+/** https://alpha.wagmi.sh/react/api/hooks/useReconnect */
+export function useReconnect<context = unknown>(
+  parameters: UseReconnectParameters<context> = {},
+): UseReconnectReturnType<context> {
+  const { mutation } = parameters
+
+  const config = useConfig(parameters)
+
+  const mutationOptions = reconnectMutationOptions(config)
+  const { mutate, mutateAsync, ...result } = useMutation({
+    ...mutation,
+    ...mutationOptions,
+  })
+
+  return {
+    ...result,
+    connectors: config.connectors,
+    reconnect: mutate,
+    reconnectAsync: mutateAsync,
+  }
+}

package/src/hooks/useSendTransaction.ts

@@ -0,0 +1,79 @@
+'use client'
+
+import { useMutation } from '@tanstack/react-query'
+import type {
+  Config,
+  ResolvedRegister,
+  SendTransactionError,
+} from '@wagmi/core'
+import type { Evaluate } from '@wagmi/core/internal'
+import {
+  type SendTransactionData,
+  type SendTransactionMutate,
+  type SendTransactionMutateAsync,
+  type SendTransactionVariables,
+  sendTransactionMutationOptions,
+} from '@wagmi/core/query'
+
+import type { ConfigParameter } from '../types/properties.js'
+import type {
+  UseMutationParameters,
+  UseMutationReturnType,
+} from '../utils/query.js'
+import { useConfig } from './useConfig.js'
+
+export type UseSendTransactionParameters<
+  config extends Config = Config,
+  context = unknown,
+> = Evaluate<
+  ConfigParameter<config> & {
+    mutation?:
+      | UseMutationParameters<
+          SendTransactionData,
+          SendTransactionError,
+          SendTransactionVariables<config, config['chains'][number]['id']>,
+          context
+        >
+      | undefined
+  }
+>
+
+export type UseSendTransactionReturnType<
+  config extends Config = Config,
+  context = unknown,
+> = Evaluate<
+  UseMutationReturnType<
+    SendTransactionData,
+    SendTransactionError,
+    SendTransactionVariables<config, config['chains'][number]['id']>,
+    context
+  > & {
+    sendTransaction: SendTransactionMutate<config, context>
+    sendTransactionAsync: SendTransactionMutateAsync<config, context>
+  }
+>
+
+/** https://alpha.wagmi.sh/react/api/hooks/useSendTransaction */
+export function useSendTransaction<
+  config extends Config = ResolvedRegister['config'],
+  context = unknown,
+>(
+  parameters: UseSendTransactionParameters<config, context> = {},
+): UseSendTransactionReturnType<config, context> {
+  const { mutation } = parameters
+
+  const config = useConfig(parameters)
+
+  const mutationOptions = sendTransactionMutationOptions(config)
+  const { mutate, mutateAsync, ...result } = useMutation({
+    ...mutation,
+    ...mutationOptions,
+  })
+
+  type Return = UseSendTransactionReturnType<config, context>
+  return {
+    ...result,
+    sendTransaction: mutate as Return['sendTransaction'],
+    sendTransactionAsync: mutateAsync as Return['sendTransactionAsync'],
+  }
+}

package/src/hooks/useSignMessage.ts

@@ -0,0 +1,65 @@
+'use client'
+
+import { useMutation } from '@tanstack/react-query'
+import { type SignMessageError } from '@wagmi/core'
+import type { Evaluate } from '@wagmi/core/internal'
+import {
+  type SignMessageData,
+  type SignMessageMutate,
+  type SignMessageMutateAsync,
+  type SignMessageVariables,
+  signMessageMutationOptions,
+} from '@wagmi/core/query'
+
+import type { ConfigParameter } from '../types/properties.js'
+import type {
+  UseMutationParameters,
+  UseMutationReturnType,
+} from '../utils/query.js'
+import { useConfig } from './useConfig.js'
+
+export type UseSignMessageParameters<context = unknown> = Evaluate<
+  ConfigParameter & {
+    mutation?:
+      | UseMutationParameters<
+          SignMessageData,
+          SignMessageError,
+          SignMessageVariables,
+          context
+        >
+      | undefined
+  }
+>
+
+export type UseSignMessageReturnType<context = unknown> = Evaluate<
+  UseMutationReturnType<
+    SignMessageData,
+    SignMessageError,
+    SignMessageVariables,
+    context
+  > & {
+    signMessage: SignMessageMutate<context>
+    signMessageAsync: SignMessageMutateAsync<context>
+  }
+>
+
+/** https://alpha.wagmi.sh/react/api/hooks/useSignMessage */
+export function useSignMessage<context = unknown>(
+  parameters: UseSignMessageParameters<context> = {},
+): UseSignMessageReturnType<context> {
+  const { mutation } = parameters
+
+  const config = useConfig(parameters)
+
+  const mutationOptions = signMessageMutationOptions(config)
+  const { mutate, mutateAsync, ...result } = useMutation({
+    ...mutation,
+    ...mutationOptions,
+  })
+
+  return {
+    ...result,
+    signMessage: mutate,
+    signMessageAsync: mutateAsync,
+  }
+}

package/src/hooks/useSignTypedData.ts

@@ -0,0 +1,66 @@
+'use client'
+
+import { useMutation } from '@tanstack/react-query'
+import type { SignTypedDataError } from '@wagmi/core'
+import type { Evaluate } from '@wagmi/core/internal'
+import {
+  type SignTypedDataData,
+  type SignTypedDataMutate,
+  type SignTypedDataMutateAsync,
+  type SignTypedDataVariables,
+  signTypedDataMutationOptions,
+} from '@wagmi/core/query'
+
+import type { ConfigParameter } from '../types/properties.js'
+import type {
+  UseMutationParameters,
+  UseMutationReturnType,
+} from '../utils/query.js'
+import { useConfig } from './useConfig.js'
+
+export type UseSignTypedDataParameters<context = unknown> = Evaluate<
+  ConfigParameter & {
+    mutation?:
+      | UseMutationParameters<
+          SignTypedDataData,
+          SignTypedDataError,
+          SignTypedDataVariables,
+          context
+        >
+      | undefined
+  }
+>
+
+export type UseSignTypedDataReturnType<context = unknown> = Evaluate<
+  UseMutationReturnType<
+    SignTypedDataData,
+    SignTypedDataError,
+    SignTypedDataVariables,
+    context
+  > & {
+    signTypedData: SignTypedDataMutate<context>
+    signTypedDataAsync: SignTypedDataMutateAsync<context>
+  }
+>
+
+/** https://alpha.wagmi.sh/react/api/hooks/useSignTypedData */
+export function useSignTypedData<context = unknown>(
+  parameters: UseSignTypedDataParameters<context> = {},
+): UseSignTypedDataReturnType<context> {
+  const { mutation } = parameters
+
+  const config = useConfig(parameters)
+
+  const mutationOptions = signTypedDataMutationOptions(config)
+  const { mutate, mutateAsync, ...result } = useMutation({
+    ...mutation,
+    ...mutationOptions,
+  })
+
+  type Return = UseSignTypedDataReturnType<context>
+  return {
+    ...result,
+    signTypedData: mutate as Return['signTypedData'],
+    signTypedDataAsync: mutateAsync as Return['signTypedDataAsync'],
+  }
+}

package/src/hooks/useSwitchAccount.ts

@@ -0,0 +1,82 @@
+'use client'
+
+import { useMutation } from '@tanstack/react-query'
+import type {
+  Config,
+  Connector,
+  ResolvedRegister,
+  SwitchAccountError,
+} from '@wagmi/core'
+import type { Evaluate } from '@wagmi/core/internal'
+import {
+  type SwitchAccountData,
+  type SwitchAccountMutate,
+  type SwitchAccountMutateAsync,
+  type SwitchAccountVariables,
+  switchAccountMutationOptions,
+} from '@wagmi/core/query'
+
+import type { ConfigParameter } from '../types/properties.js'
+import type {
+  UseMutationParameters,
+  UseMutationReturnType,
+} from '../utils/query.js'
+import { useConfig } from './useConfig.js'
+import { useConnections } from './useConnections.js'
+
+export type UseSwitchAccountParameters<
+  config extends Config = Config,
+  context = unknown,
+> = Evaluate<
+  ConfigParameter<config> & {
+    mutation?:
+      | UseMutationParameters<
+          SwitchAccountData<config>,
+          SwitchAccountError,
+          SwitchAccountVariables,
+          context
+        >
+      | undefined
+  }
+>
+
+export type UseSwitchAccountReturnType<
+  config extends Config = Config,
+  context = unknown,
+> = Evaluate<
+  UseMutationReturnType<
+    SwitchAccountData<config>,
+    SwitchAccountError,
+    SwitchAccountVariables,
+    context
+  > & {
+    connectors: readonly Connector[]
+    switchAccount: SwitchAccountMutate<config, context>
+    switchAccountAsync: SwitchAccountMutateAsync<config, context>
+  }
+>
+
+/** https://alpha.wagmi.sh/react/api/hooks/useSwitchAccount */
+export function useSwitchAccount<
+  config extends Config = ResolvedRegister['config'],
+  context = unknown,
+>(
+  parameters: UseSwitchAccountParameters<config, context> = {},
+): UseSwitchAccountReturnType<config, context> {
+  const { mutation } = parameters
+
+  const config = useConfig(parameters)
+
+  const mutationOptions = switchAccountMutationOptions(config)
+  const { mutate, mutateAsync, ...result } = useMutation({
+    ...mutation,
+    ...mutationOptions,
+  })
+
+  return {
+    ...result,
+    connectors: useConnections().map((connection) => connection.connector),
+    switchAccount: mutate,
+    switchAccountAsync: mutateAsync,
+  }
+}

package/src/hooks/useSwitchChain.ts

@@ -0,0 +1,77 @@
+'use client'
+
+import { useMutation } from '@tanstack/react-query'
+import type { Config, ResolvedRegister, SwitchChainError } from '@wagmi/core'
+import type { Evaluate } from '@wagmi/core/internal'
+import {
+  type SwitchChainData,
+  type SwitchChainMutate,
+  type SwitchChainMutateAsync,
+  type SwitchChainVariables,
+  switchChainMutationOptions,
+} from '@wagmi/core/query'
+
+import type { ConfigParameter } from '../types/properties.js'
+import type {
+  UseMutationParameters,
+  UseMutationReturnType,
+} from '../utils/query.js'
+import { useConfig } from './useConfig.js'
+
+export type UseSwitchChainParameters<
+  config extends Config = Config,
+  context = unknown,
+> = Evaluate<
+  ConfigParameter<config> & {
+    mutation?:
+      | UseMutationParameters<
+          SwitchChainData<config, config['chains'][number]['id']>,
+          SwitchChainError,
+          SwitchChainVariables<config, config['chains'][number]['id']>,
+          context
+        >
+      | undefined
+  }
+>
+
+export type UseSwitchChainReturnType<
+  config extends Config = Config,
+  context = unknown,
+> = Evaluate<
+  UseMutationReturnType<
+    SwitchChainData<config, config['chains'][number]['id']>,
+    SwitchChainError,
+    SwitchChainVariables<config, config['chains'][number]['id']>,
+    context
+  > & {
+    chains: config['chains']
+    switchChain: SwitchChainMutate<config, context>
+    switchChainAsync: SwitchChainMutateAsync<config, context>
+  }
+>
+
+/** https://alpha.wagmi.sh/react/api/hooks/useSwitchChain */
+export function useSwitchChain<
+  config extends Config = ResolvedRegister['config'],
+  context = unknown,
+>(
+  parameters: UseSwitchChainParameters<config, context> = {},
+): UseSwitchChainReturnType<config, context> {
+  const { mutation } = parameters
+
+  const config = useConfig(parameters)
+
+  const mutationOptions = switchChainMutationOptions(config)
+  const { mutate, mutateAsync, ...result } = useMutation({
+    ...mutation,
+    ...mutationOptions,
+  })
+
+  type Return = UseSwitchChainReturnType<config, context>
+  return {
+    ...result,
+    chains: config.chains,
+    switchChain: mutate as Return['switchChain'],
+    switchChainAsync: mutateAsync as Return['switchChainAsync'],
+  }
+}

package/src/hooks/useSyncExternalStoreWithTracked.ts

@@ -0,0 +1,67 @@
+'use client'
+
+import { deepEqual } from '@wagmi/core/internal'
+import { useRef } from 'react'
+import { useSyncExternalStoreWithSelector } from 'use-sync-external-store/shim/with-selector.js'
+
+const isPlainObject = (obj: unknown) =>
+  typeof obj === 'object' && !Array.isArray(obj)
+
+export function useSyncExternalStoreWithTracked<
+  snapshot extends selection,
+  selection = snapshot,
+>(
+  subscribe: (onStoreChange: () => void) => () => void,
+  getSnapshot: () => snapshot,
+  getServerSnapshot: undefined | null | (() => snapshot) = getSnapshot,
+  isEqual: (a: selection, b: selection) => boolean = deepEqual,
+) {
+  const trackedKeys = useRef<string[]>([])
+  const result = useSyncExternalStoreWithSelector(
+    subscribe,
+    getSnapshot,
+    getServerSnapshot,
+    (x) => x,
+    (a, b) => {
+      if (isPlainObject(a) && isPlainObject(b) && trackedKeys.current.length) {
+        for (const key of trackedKeys.current) {
+          const equal = isEqual(
+            (a as { [_a: string]: any })[key],
+            (b as { [_b: string]: any })[key],
+          )
+          if (!equal) return false
+        }
+        return true
+      }
+      return isEqual(a, b)
+    },
+  )
+
+  if (isPlainObject(result)) {
+    const trackedResult = { ...result }
+    Object.defineProperties(
+      trackedResult,
+      Object.entries(trackedResult as { [key: string]: any }).reduce(
+        (res, [key, value]) => {
+          return {
+            ...res,
+            [key]: {
+              configurable: false,
+              enumerable: true,
+              get: () => {
+                if (!trackedKeys.current.includes(key)) {
+                  trackedKeys.current.push(key)
+                }
+                return value
+              },
+            },
+          }
+        },
+        {},
+      ),
+    )
+    return trackedResult
+  }
+
+  return result
+}

package/src/hooks/useToken.ts

@@ -0,0 +1,63 @@
+'use client'
+
+import type { Config, GetTokenError, ResolvedRegister } from '@wagmi/core'
+import { type Evaluate } from '@wagmi/core/internal'
+import {
+  type GetTokenData,
+  type GetTokenOptions,
+  type GetTokenQueryFnData,
+  type GetTokenQueryKey,
+  getTokenQueryOptions,
+} from '@wagmi/core/query'
+
+import type { ConfigParameter } from '../types/properties.js'
+import {
+  type UseQueryParameters,
+  type UseQueryReturnType,
+  useQuery,
+} from '../utils/query.js'
+import { useChainId } from './useChainId.js'
+import { useConfig } from './useConfig.js'
+
+export type UseTokenParameters<
+  config extends Config = Config,
+  selectData = GetTokenData,
+> = Evaluate<
+  GetTokenOptions<config> &
+    ConfigParameter<config> & {
+      query?:
+        | UseQueryParameters<
+            GetTokenQueryFnData,
+            GetTokenError,
+            selectData,
+            GetTokenQueryKey<config>
+          >
+        | undefined
+    }
+>
+
+export type UseTokenReturnType<selectData = GetTokenData> = UseQueryReturnType<
+  selectData,
+  GetTokenError
+>
+
+/** https://alpha.wagmi.sh/react/api/hooks/useToken */
+export function useToken<
+  config extends Config = ResolvedRegister['config'],
+  selectData = GetTokenData,
+>(
+  parameters: UseTokenParameters<config, selectData> = {},
+): UseTokenReturnType<selectData> {
+  const { address, query = {} } = parameters
+
+  const config = useConfig(parameters)
+  const chainId = useChainId()
+
+  const queryOptions = getTokenQueryOptions(config, {
+    ...parameters,
+    chainId: parameters.chainId ?? chainId,
+  })
+  const enabled = Boolean(address && (query.enabled ?? true))
+
+  return useQuery({ ...queryOptions, ...query, enabled })
+}

package/src/hooks/useTransaction.ts

@@ -0,0 +1,68 @@
+'use client'
+
+import type { Config, GetTransactionError, ResolvedRegister } from '@wagmi/core'
+import { type Evaluate } from '@wagmi/core/internal'
+import {
+  type GetTransactionData,
+  type GetTransactionOptions,
+  type GetTransactionQueryFnData,
+  type GetTransactionQueryKey,
+  getTransactionQueryOptions,
+} from '@wagmi/core/query'
+
+import type { ConfigParameter } from '../types/properties.js'
+import {
+  type UseQueryParameters,
+  type UseQueryReturnType,
+  useQuery,
+} from '../utils/query.js'
+import { useChainId } from './useChainId.js'
+import { useConfig } from './useConfig.js'
+
+export type UseTransactionParameters<
+  config extends Config = Config,
+  chainId extends config['chains'][number]['id'] = config['chains'][number]['id'],
+  selectData = GetTransactionData<config, chainId>,
+> = Evaluate<
+  GetTransactionOptions<config, chainId> &
+    ConfigParameter<config> & {
+      query?:
+        | UseQueryParameters<
+            GetTransactionQueryFnData<config, chainId>,
+            GetTransactionError,
+            selectData,
+            GetTransactionQueryKey<config, chainId>
+          >
+        | undefined
+    }
+>
+
+export type UseTransactionReturnType<
+  config extends Config = Config,
+  chainId extends config['chains'][number]['id'] = config['chains'][number]['id'],
+  selectData = GetTransactionData<config, chainId>,
+> = UseQueryReturnType<selectData, GetTransactionError>
+
+/** https://alpha.wagmi.sh/react/api/hooks/useTransaction */
+export function useTransaction<
+  config extends Config = ResolvedRegister['config'],
+  chainId extends config['chains'][number]['id'] = config['chains'][number]['id'],
+  selectData = GetTransactionData<config, chainId>,
+>(
+  parameters: UseTransactionParameters<config, chainId, selectData> = {},
+): UseTransactionReturnType<config, chainId, selectData> {
+  const { blockHash, blockNumber, blockTag, hash, query = {} } = parameters
+
+  const config = useConfig(parameters)
+  const chainId = useChainId()
+
+  const queryOptions = getTransactionQueryOptions(config, {
+    ...parameters,
+    chainId: parameters.chainId ?? chainId,
+  })
+  const enabled = Boolean(
+    !(blockHash && blockNumber && blockTag && hash) && (query.enabled ?? true),
+  )
+
+  return useQuery({ ...queryOptions, ...query, enabled })
+}