wagmi 2.0.0 → 2.0.1

package/src/hooks/codegen/createUseSimulateContract.ts

@@ -0,0 +1,121 @@
+import {
+  type Config,
+  type ResolvedRegister,
+  type SimulateContractErrorType,
+  type SimulateContractParameters,
+} from '@wagmi/core'
+import { type ScopeKeyParameter, type UnionPartial } from '@wagmi/core/internal'
+import {
+  type SimulateContractData,
+  type SimulateContractQueryFnData,
+  type SimulateContractQueryKey,
+} from '@wagmi/core/query'
+import {
+  type Abi,
+  type Address,
+  type ContractFunctionArgs,
+  type ContractFunctionName,
+} from 'viem'
+
+import {
+  type ConfigParameter,
+  type QueryParameter,
+} from '../../types/properties.js'
+import { useAccount } from '../useAccount.js'
+import { useChainId } from '../useChainId.js'
+import {
+  type UseSimulateContractReturnType,
+  useSimulateContract,
+} from '../useSimulateContract.js'
+
+type stateMutability = 'nonpayable' | 'payable'
+
+export type CreateUseSimulateContractParameters<
+  abi extends Abi | readonly unknown[],
+  address extends Address | Record<number, Address> | undefined = undefined,
+  functionName extends
+    | ContractFunctionName<abi, stateMutability>
+    | undefined = undefined,
+> = {
+  abi: abi | Abi | readonly unknown[]
+  address?: address | Address | Record<number, Address> | undefined
+  functionName?:
+    | functionName
+    | ContractFunctionName<abi, stateMutability>
+    | undefined
+}
+
+export type CreateUseSimulateContractReturnType<
+  abi extends Abi | readonly unknown[],
+  address extends Address | Record<number, Address> | undefined,
+  functionName extends ContractFunctionName<abi, stateMutability> | undefined,
+> = <
+  name extends functionName extends ContractFunctionName<abi, stateMutability>
+    ? functionName
+    : ContractFunctionName<abi, stateMutability>,
+  args extends ContractFunctionArgs<abi, stateMutability, name>,
+  config extends Config = ResolvedRegister['config'],
+  chainId extends config['chains'][number]['id'] | undefined = undefined,
+  selectData = SimulateContractData<abi, name, args, config, chainId>,
+>(
+  parameters?: {
+    abi?: undefined
+    address?: address extends undefined ? Address : undefined
+    functionName?: functionName extends undefined ? name : undefined
+    chainId?: address extends Record<number, Address>
+      ?
+          | keyof address
+          | (chainId extends keyof address ? chainId : never)
+          | undefined
+      : chainId | number | undefined
+  } & UnionPartial<
+    // TODO: Take `abi` and `address` from above and omit from below (currently breaks inference)
+    SimulateContractParameters<abi, name, args, config, chainId>
+  > &
+    ScopeKeyParameter &
+    ConfigParameter<config> &
+    QueryParameter<
+      SimulateContractQueryFnData<abi, name, args, config, chainId>,
+      SimulateContractErrorType,
+      selectData,
+      SimulateContractQueryKey<abi, name, args, config, chainId>
+    >,
+) => UseSimulateContractReturnType<abi, name, args, config, chainId, selectData>
+
+export function createUseSimulateContract<
+  const abi extends Abi | readonly unknown[],
+  const address extends
+    | Address
+    | Record<number, Address>
+    | undefined = undefined,
+  functionName extends
+    | ContractFunctionName<abi, stateMutability>
+    | undefined = undefined,
+>(
+  config: CreateUseSimulateContractParameters<abi, address, functionName>,
+): CreateUseSimulateContractReturnType<abi, address, functionName> {
+  if (config.address !== undefined && typeof config.address === 'object')
+    return (parameters) => {
+      const configChainId = useChainId()
+      const account = useAccount()
+      const chainId =
+        (parameters as { chainId?: number })?.chainId ??
+        account.chainId ??
+        configChainId
+      return useSimulateContract({
+        ...(parameters as any),
+        ...(config.functionName ? { functionName: config.functionName } : {}),
+        address: config.address?.[chainId],
+        abi: config.abi,
+      })
+    }
+
+  return (parameters) => {
+    return useSimulateContract({
+      ...(parameters as any),
+      ...(config.address ? { address: config.address } : {}),
+      ...(config.functionName ? { functionName: config.functionName } : {}),
+      abi: config.abi,
+    })
+  }
+}

package/src/hooks/codegen/createUseWatchContractEvent.ts

@@ -0,0 +1,98 @@
+import {
+  type Config,
+  type ResolvedRegister,
+  type WatchContractEventParameters,
+} from '@wagmi/core'
+import {
+  type UnionEvaluate,
+  type UnionOmit,
+  type UnionPartial,
+} from '@wagmi/core/internal'
+import { type Abi, type Address, type ContractEventName } from 'viem'
+
+import {
+  type ConfigParameter,
+  type EnabledParameter,
+} from '../../types/properties.js'
+import { useAccount } from '../useAccount.js'
+import { useChainId } from '../useChainId.js'
+import { useWatchContractEvent } from '../useWatchContractEvent.js'
+
+export type CreateUseWatchContractEventParameters<
+  abi extends Abi | readonly unknown[],
+  address extends Address | Record<number, Address> | undefined = undefined,
+  eventName extends ContractEventName<abi> | undefined = undefined,
+> = {
+  abi: abi | Abi | readonly unknown[]
+  address?: address | Address | Record<number, Address> | undefined
+  eventName?: eventName | ContractEventName<abi> | undefined
+}
+
+export type CreateUseWatchContractEventReturnType<
+  abi extends Abi | readonly unknown[],
+  address extends Address | Record<number, Address> | undefined,
+  eventName extends ContractEventName<abi> | undefined,
+  ///
+  omittedProperties extends 'abi' | 'address' | 'chainId' | 'eventName' =
+    | 'abi'
+    | (address extends undefined ? never : 'address')
+    | (address extends Record<number, Address> ? 'chainId' : never)
+    | (eventName extends undefined ? never : 'eventName'),
+> = <
+  name extends eventName extends ContractEventName<abi>
+    ? eventName
+    : ContractEventName<abi>,
+  strict extends boolean | undefined = undefined,
+  config extends Config = ResolvedRegister['config'],
+  chainId extends config['chains'][number]['id'] = config['chains'][number]['id'],
+>(
+  parameters?: UnionEvaluate<
+    UnionPartial<
+      UnionOmit<
+        WatchContractEventParameters<abi, name, strict, config, chainId>,
+        omittedProperties
+      >
+    > &
+      ConfigParameter<config> &
+      EnabledParameter
+  > &
+    (address extends Record<number, Address>
+      ? { chainId?: keyof address | undefined }
+      : unknown),
+) => void
+
+export function createUseWatchContractEvent<
+  const abi extends Abi | readonly unknown[],
+  const address extends
+    | Address
+    | Record<number, Address>
+    | undefined = undefined,
+  eventName extends ContractEventName<abi> | undefined = undefined,
+>(
+  config: CreateUseWatchContractEventParameters<abi, address, eventName>,
+): CreateUseWatchContractEventReturnType<abi, address, eventName> {
+  if (config.address !== undefined && typeof config.address === 'object')
+    return (parameters) => {
+      const configChainId = useChainId()
+      const account = useAccount()
+      const chainId =
+        (parameters as { chainId?: number })?.chainId ??
+        account.chainId ??
+        configChainId
+      return useWatchContractEvent({
+        ...(parameters as any),
+        ...(config.eventName ? { eventName: config.eventName } : {}),
+        address: config.address?.[chainId],
+        abi: config.abi,
+      })
+    }
+
+  return (parameters) => {
+    return useWatchContractEvent({
+      ...(parameters as any),
+      ...(config.address ? { address: config.address } : {}),
+      ...(config.eventName ? { eventName: config.eventName } : {}),
+      abi: config.abi,
+    })
+  }
+}

package/src/hooks/codegen/createUseWriteContract.ts

@@ -0,0 +1,290 @@
+import { type MutateOptions } from '@tanstack/react-query'
+import {
+  type Config,
+  type ResolvedRegister,
+  type WriteContractErrorType,
+} from '@wagmi/core'
+import type {
+  ChainIdParameter,
+  ConnectorParameter,
+  Evaluate,
+  SelectChains,
+  UnionEvaluate,
+  UnionOmit,
+} from '@wagmi/core/internal'
+import {
+  type WriteContractData,
+  type WriteContractVariables,
+} from '@wagmi/core/query'
+import { useCallback } from 'react'
+import {
+  type Abi,
+  type Account,
+  type Address,
+  type Chain,
+  type ContractFunctionArgs,
+  type ContractFunctionName,
+} from 'viem'
+import { type WriteContractParameters as viem_WriteContractParameters } from 'viem/actions'
+
+import { useAccount } from '../useAccount.js'
+import { useChainId } from '../useChainId.js'
+import {
+  type UseWriteContractParameters,
+  type UseWriteContractReturnType as wagmi_UseWriteContractReturnType,
+  useWriteContract,
+} from '../useWriteContract.js'
+
+type stateMutability = 'nonpayable' | 'payable'
+
+export type CreateUseWriteContractParameters<
+  abi extends Abi | readonly unknown[],
+  address extends Address | Record<number, Address> | undefined = undefined,
+  functionName extends
+    | ContractFunctionName<abi, stateMutability>
+    | undefined = undefined,
+> = {
+  abi: abi | Abi | readonly unknown[]
+  address?: address | Address | Record<number, Address> | undefined
+  functionName?:
+    | functionName
+    | ContractFunctionName<abi, stateMutability>
+    | undefined
+}
+
+export type CreateUseWriteContractReturnType<
+  abi extends Abi | readonly unknown[],
+  address extends Address | Record<number, Address> | undefined,
+  functionName extends ContractFunctionName<abi, stateMutability> | undefined,
+> = <config extends Config = ResolvedRegister['config'], context = unknown>(
+  parameters?: UseWriteContractParameters<config, context>,
+) => Evaluate<
+  Omit<
+    wagmi_UseWriteContractReturnType<config, context>,
+    'writeContract' | 'writeContractAsync'
+  > & {
+    writeContract: <
+      const abi2 extends abi,
+      name extends functionName extends ContractFunctionName<
+        abi,
+        stateMutability
+      >
+        ? functionName
+        : ContractFunctionName<abi, stateMutability>,
+      args extends ContractFunctionArgs<abi2, stateMutability, name>,
+      chainId extends config['chains'][number]['id'],
+    >(
+      variables: Variables<
+        abi2,
+        functionName,
+        name,
+        args,
+        config,
+        chainId,
+        address
+      >,
+      options?:
+        | MutateOptions<
+            WriteContractData,
+            WriteContractErrorType,
+            WriteContractVariables<
+              abi2,
+              name,
+              args,
+              config,
+              chainId,
+              // use `functionName` to make sure it's not union of all possible function names
+              name
+            >,
+            context
+          >
+        | undefined,
+    ) => void
+    writeContractAsync: <
+      const abi2 extends abi,
+      name extends functionName extends ContractFunctionName<
+        abi,
+        stateMutability
+      >
+        ? functionName
+        : ContractFunctionName<abi, stateMutability>,
+      args extends ContractFunctionArgs<abi2, stateMutability, name>,
+      chainId extends config['chains'][number]['id'],
+    >(
+      variables: Variables<
+        abi2,
+        functionName,
+        name,
+        args,
+        config,
+        chainId,
+        address
+      >,
+      options?:
+        | MutateOptions<
+            WriteContractData,
+            WriteContractErrorType,
+            WriteContractVariables<
+              abi2,
+              name,
+              args,
+              config,
+              chainId,
+              // use `functionName` to make sure it's not union of all possible function names
+              name
+            >,
+            context
+          >
+        | undefined,
+    ) => Promise<WriteContractData>
+  }
+>
+
+export function createUseWriteContract<
+  const abi extends Abi | readonly unknown[],
+  const address extends
+    | Address
+    | Record<number, Address>
+    | undefined = undefined,
+  functionName extends
+    | ContractFunctionName<abi, stateMutability>
+    | undefined = undefined,
+>(
+  config: CreateUseWriteContractParameters<abi, address, functionName>,
+): CreateUseWriteContractReturnType<abi, address, functionName> {
+  if (config.address !== undefined && typeof config.address === 'object')
+    return (parameters) => {
+      const result = useWriteContract(parameters)
+      const configChainId = useChainId()
+      const account = useAccount()
+      type Args = Parameters<wagmi_UseWriteContractReturnType['writeContract']>
+      return {
+        ...(result as any),
+        writeContract: useCallback(
+          (...args: Args) => {
+            let chainId
+            if (args[0].chainId) chainId = args[0].chainId
+            else if (args[0].account && args[0].account === account.address)
+              chainId = account.chainId
+            else if (args[0].account === undefined) chainId = account.chainId
+            else chainId = configChainId
+
+            const variables = {
+              ...(args[0] as any),
+              address: chainId ? config.address?.[chainId] : undefined,
+              abi: config.abi,
+            }
+            result.writeContract(variables, args[1] as any)
+          },
+          [
+            account.address,
+            account.chainId,
+            config,
+            configChainId,
+            result.writeContract,
+          ],
+        ),
+        writeContractAsync: useCallback(
+          (...args: Args) => {
+            let chainId
+            if (args[0].chainId) chainId = args[0].chainId
+            else if (args[0].account && args[0].account === account.address)
+              chainId = account.chainId
+            else if (args[0].account === undefined) chainId = account.chainId
+            else chainId = configChainId
+
+            const variables = {
+              ...(args[0] as any),
+              address: chainId ? config.address?.[chainId] : undefined,
+              abi: config.abi,
+            }
+            return result.writeContractAsync(variables, args[1] as any)
+          },
+          [
+            account.address,
+            account.chainId,
+            config,
+            configChainId,
+            result.writeContractAsync,
+          ],
+        ),
+      }
+    }
+
+  return (parameters) => {
+    const result = useWriteContract(parameters)
+    type Args = Parameters<wagmi_UseWriteContractReturnType['writeContract']>
+    return {
+      ...(result as any),
+      writeContract: useCallback(
+        (...args: Args) => {
+          const variables = {
+            ...(args[0] as any),
+            ...(config.address ? { address: config.address } : {}),
+            ...(config.functionName
+              ? { functionName: config.functionName }
+              : {}),
+            abi: config.abi,
+          }
+          result.writeContract(variables, args[1] as any)
+        },
+        [config, result.writeContract],
+      ),
+      writeContractAsync: useCallback(
+        (...args: Args) => {
+          const variables = {
+            ...(args[0] as any),
+            ...(config.address ? { address: config.address } : {}),
+            ...(config.functionName
+              ? { functionName: config.functionName }
+              : {}),
+            abi: config.abi,
+          }
+          return result.writeContractAsync(variables, args[1] as any)
+        },
+        [config, result.writeContractAsync],
+      ),
+    }
+  }
+}
+
+type Variables<
+  abi extends Abi | readonly unknown[],
+  functionName extends ContractFunctionName<abi, stateMutability> | undefined,
+  name extends ContractFunctionName<abi, stateMutability>,
+  args extends ContractFunctionArgs<abi, stateMutability, name>,
+  config extends Config,
+  chainId extends config['chains'][number]['id'],
+  address extends Address | Record<number, Address> | undefined,
+  ///
+  allFunctionNames = ContractFunctionName<abi, stateMutability>,
+  chains extends readonly Chain[] = SelectChains<config, chainId>,
+  omittedProperties extends 'abi' | 'address' | 'functionName' =
+    | 'abi'
+    | (address extends undefined ? never : 'address')
+    | (functionName extends undefined ? never : 'functionName'),
+> = UnionEvaluate<
+  {
+    [key in keyof chains]: UnionOmit<
+      viem_WriteContractParameters<
+        abi,
+        name,
+        args,
+        chains[key],
+        Account,
+        chains[key],
+        allFunctionNames
+      >,
+      omittedProperties | 'chain'
+    >
+  }[number] &
+    (address extends Record<number, Address>
+      ? {
+          chainId?:
+            | keyof address
+            | (chainId extends keyof address ? chainId : never)
+            | undefined
+        }
+      : Evaluate<ChainIdParameter<config, chainId>>) &
+    ConnectorParameter & { __mode?: 'prepared' }
+>

package/src/hooks/useAccount.ts

@@ -14,7 +14,7 @@ export type UseAccountParameters = ConfigParameter
 
 export type UseAccountReturnType = GetAccountReturnType
 
-/** https://alpha.wagmi.sh/react/api/hooks/useAccount */
+/** https://wagmi.sh/react/api/hooks/useAccount */
 export function useAccount(
   parameters: UseAccountParameters = {},
 ): UseAccountReturnType {

package/src/hooks/useAccountEffect.ts

@@ -13,7 +13,7 @@ export type UseAccountEffectParameters = Evaluate<
       data: Evaluate<
         Pick<
           Extract<GetAccountReturnType, { status: 'connected' }>,
-          'address' | 'addresses' | 'chainId' | 'connector'
+          'address' | 'addresses' | 'chain' | 'chainId' | 'connector'
         > & {
           isReconnected: boolean
         }
@@ -23,7 +23,7 @@ export type UseAccountEffectParameters = Evaluate<
   } & ConfigParameter
 >
 
-/** https://alpha.wagmi.sh/react/api/hooks/useAccountEffect */
+/** https://wagmi.sh/react/api/hooks/useAccountEffect */
 export function useAccountEffect(parameters: UseAccountEffectParameters = {}) {
   const { onConnect, onDisconnect } = parameters
 
@@ -38,12 +38,19 @@ export function useAccountEffect(parameters: UseAccountEffectParameters = {}) {
               prevData.address === undefined)) &&
           data.status === 'connected'
         ) {
-          const { address, addresses, chainId, connector } = data
+          const { address, addresses, chain, chainId, connector } = data
           const isReconnected =
             prevData.status === 'reconnecting' ||
             // if `previousAccount.status` is `undefined`, the connector connected immediately.
             prevData.status === undefined
-          onConnect?.({ address, addresses, chainId, connector, isReconnected })
+          onConnect?.({
+            address,
+            addresses,
+            chain,
+            chainId,
+            connector,
+            isReconnected,
+          })
         } else if (
           prevData.status === 'connected' &&
           data.status === 'disconnected'

package/src/hooks/useBalance.ts

@@ -2,7 +2,7 @@
 
 import {
   type Config,
-  type GetBalanceError,
+  type GetBalanceErrorType,
   type ResolvedRegister,
 } from '@wagmi/core'
 import type { Evaluate } from '@wagmi/core/internal'
@@ -14,12 +14,8 @@ import {
 } from '@wagmi/core/query'
 import type { GetBalanceQueryFnData } from '@wagmi/core/query'
 
-import type { ConfigParameter } from '../types/properties.js'
-import {
-  type UseQueryParameters,
-  type UseQueryReturnType,
-  useQuery,
-} from '../utils/query.js'
+import type { ConfigParameter, QueryParameter } from '../types/properties.js'
+import { type UseQueryReturnType, useQuery } from '../utils/query.js'
 import { useChainId } from './useChainId.js'
 import { useConfig } from './useConfig.js'
 
@@ -28,22 +24,19 @@ export type UseBalanceParameters<
   selectData = GetBalanceData,
 > = Evaluate<
   GetBalanceOptions<config> &
-    ConfigParameter<config> & {
-      query?:
-        | UseQueryParameters<
-            GetBalanceQueryFnData,
-            GetBalanceError,
-            selectData,
-            GetBalanceQueryKey<config>
-          >
-        | undefined
-    }
+    ConfigParameter<config> &
+    QueryParameter<
+      GetBalanceQueryFnData,
+      GetBalanceErrorType,
+      selectData,
+      GetBalanceQueryKey<config>
+    >
 >
 
 export type UseBalanceReturnType<selectData = GetBalanceData> =
-  UseQueryReturnType<selectData, GetBalanceError>
+  UseQueryReturnType<selectData, GetBalanceErrorType>
 
-/** https://alpha.wagmi.sh/react/api/hooks/useBalance */
+/** https://wagmi.sh/react/api/hooks/useBalance */
 export function useBalance<
   config extends Config = ResolvedRegister['config'],
   selectData = GetBalanceData,
@@ -55,11 +48,11 @@ export function useBalance<
   const config = useConfig(parameters)
   const chainId = useChainId()
 
-  const queryOptions = getBalanceQueryOptions(config, {
+  const options = getBalanceQueryOptions(config, {
     ...parameters,
     chainId: parameters.chainId ?? chainId,
   })
   const enabled = Boolean(address && (query.enabled ?? true))
 
-  return useQuery({ ...queryOptions, ...query, enabled })
+  return useQuery({ ...query, ...options, enabled })
 }