@wagmi/core 2.0.0 → 2.0.2

package/query/package.json

@@ -0,0 +1,5 @@
+{
+  "type": "module",
+  "types": "../dist/types/exports/query.d.ts",
+  "main": "../dist/esm/exports/query.js"
+}

package/src/actions/codegen/createReadContract.ts

@@ -0,0 +1,100 @@
+import {
+  type Abi,
+  type Address,
+  type ContractFunctionArgs,
+  type ContractFunctionName,
+} from 'viem'
+
+import { type Config } from '../../createConfig.js'
+import { type UnionEvaluate, type UnionOmit } from '../../types/utils.js'
+import { getAccount } from '../getAccount.js'
+import { getChainId } from '../getChainId.js'
+import {
+  type ReadContractParameters,
+  type ReadContractReturnType,
+  readContract,
+} from '../readContract.js'
+
+type stateMutability = 'pure' | 'view'
+
+export type CreateReadContractParameters<
+  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 CreateReadContractReturnType<
+  abi extends Abi | readonly unknown[],
+  address extends Address | Record<number, Address> | undefined,
+  functionName extends ContractFunctionName<abi, stateMutability> | undefined,
+  ///
+  omittedProperties extends 'abi' | 'address' | 'chainId' | 'functionName' =
+    | 'abi'
+    | (address extends undefined ? never : 'address')
+    | (address extends Record<number, Address> ? 'chainId' : never)
+    | (functionName extends undefined ? never : 'functionName'),
+> = <
+  config extends Config,
+  name extends functionName extends ContractFunctionName<abi, stateMutability>
+    ? functionName
+    : ContractFunctionName<abi, stateMutability>,
+  args extends ContractFunctionArgs<abi, stateMutability, name>,
+>(
+  config: config,
+  parameters: UnionEvaluate<
+    UnionOmit<
+      ReadContractParameters<abi, name, args, config>,
+      omittedProperties
+    >
+  > &
+    (address extends Record<number, Address>
+      ? { chainId?: keyof address | undefined }
+      : unknown),
+) => Promise<ReadContractReturnType<abi, name, args>>
+
+export function createReadContract<
+  const abi extends Abi | readonly unknown[],
+  const address extends
+    | Address
+    | Record<number, Address>
+    | undefined = undefined,
+  functionName extends
+    | ContractFunctionName<abi, stateMutability>
+    | undefined = undefined,
+>(
+  c: CreateReadContractParameters<abi, address, functionName>,
+): CreateReadContractReturnType<abi, address, functionName> {
+  if (c.address !== undefined && typeof c.address === 'object')
+    return (config, parameters) => {
+      const configChainId = getChainId(config)
+      const account = getAccount(config)
+      const chainId =
+        (parameters as { chainId?: number })?.chainId ??
+        account.chainId ??
+        configChainId
+      return readContract(config, {
+        ...(parameters as any),
+        ...(c.functionName ? { functionName: c.functionName } : {}),
+        address: c.address?.[chainId],
+        abi: c.abi,
+      })
+    }
+
+  return (config, parameters) => {
+    return readContract(config, {
+      ...(parameters as any),
+      ...(c.address ? { address: c.address } : {}),
+      ...(c.functionName ? { functionName: c.functionName } : {}),
+      abi: c.abi,
+    })
+  }
+}

package/src/actions/codegen/createSimulateContract.ts

@@ -0,0 +1,122 @@
+import {
+  type Abi,
+  type Account,
+  type Address,
+  type Chain,
+  type ContractFunctionArgs,
+  type ContractFunctionName,
+  type SimulateContractParameters as viem_SimulateContractParameters,
+} from 'viem'
+
+import { type Config } from '../../createConfig.js'
+import { type SelectChains } from '../../types/chain.js'
+import {
+  type ChainIdParameter,
+  type ConnectorParameter,
+} from '../../types/properties.js'
+import { type UnionEvaluate, type UnionOmit } from '../../types/utils.js'
+import { getAccount } from '../getAccount.js'
+import { getChainId } from '../getChainId.js'
+import {
+  type SimulateContractReturnType,
+  simulateContract,
+} from '../simulateContract.js'
+
+type stateMutability = 'nonpayable' | 'payable'
+
+export type CreateSimulateContractParameters<
+  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 CreateSimulateContractReturnType<
+  abi extends Abi | readonly unknown[],
+  address extends Address | Record<number, Address> | undefined,
+  functionName extends ContractFunctionName<abi, stateMutability> | undefined,
+> = <
+  config extends Config,
+  name extends functionName extends ContractFunctionName<abi, stateMutability>
+    ? functionName
+    : ContractFunctionName<abi, stateMutability>,
+  args extends ContractFunctionArgs<abi, stateMutability, name>,
+  chainId extends config['chains'][number]['id'] | undefined = undefined,
+  ///
+  chains extends readonly Chain[] = SelectChains<config, chainId>,
+>(
+  config: config,
+  parameters: {
+    [key in keyof chains]: UnionEvaluate<
+      UnionOmit<
+        viem_SimulateContractParameters<
+          abi,
+          name,
+          args,
+          chains[key],
+          chains[key],
+          Account | Address
+        >,
+        | 'abi'
+        | 'chain'
+        | (address extends undefined ? never : 'address')
+        | (functionName extends undefined ? never : 'functionName')
+      >
+    > &
+      ChainIdParameter<config, chainId> &
+      ConnectorParameter & {
+        chainId?: address extends Record<number, Address>
+          ?
+              | keyof address
+              | (chainId extends keyof address ? chainId : never)
+              | undefined
+          : chainId | number | undefined
+      }
+  }[number],
+) => Promise<SimulateContractReturnType<abi, name, args, config, chainId>>
+
+export function createSimulateContract<
+  const abi extends Abi | readonly unknown[],
+  const address extends
+    | Address
+    | Record<number, Address>
+    | undefined = undefined,
+  functionName extends
+    | ContractFunctionName<abi, stateMutability>
+    | undefined = undefined,
+>(
+  c: CreateSimulateContractParameters<abi, address, functionName>,
+): CreateSimulateContractReturnType<abi, address, functionName> {
+  if (c.address !== undefined && typeof c.address === 'object')
+    return (config, parameters) => {
+      const configChainId = getChainId(config)
+      const account = getAccount(config)
+      const chainId =
+        (parameters as { chainId?: number })?.chainId ??
+        account.chainId ??
+        configChainId
+      return simulateContract(config, {
+        ...(parameters as any),
+        ...(c.functionName ? { functionName: c.functionName } : {}),
+        address: c.address?.[chainId],
+        abi: c.abi,
+      })
+    }
+
+  return (config, parameters) => {
+    return simulateContract(config, {
+      ...(parameters as any),
+      ...(c.address ? { address: c.address } : {}),
+      ...(c.functionName ? { functionName: c.functionName } : {}),
+      abi: c.abi,
+    })
+  }
+}

package/src/actions/codegen/createWatchContractEvent.ts

@@ -0,0 +1,87 @@
+import { type Abi, type Address, type ContractEventName } from 'viem'
+
+import { type Config } from '../../createConfig.js'
+import { type UnionEvaluate, type UnionOmit } from '../../types/utils.js'
+import { getAccount } from '../getAccount.js'
+import { getChainId } from '../getChainId.js'
+import {
+  type WatchContractEventParameters,
+  type WatchContractEventReturnType,
+  watchContractEvent,
+} from '../watchContractEvent.js'
+
+export type CreateWatchContractEventParameters<
+  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 CreateWatchContractEventReturnType<
+  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'),
+> = <
+  config extends Config,
+  name extends eventName extends ContractEventName<abi>
+    ? eventName
+    : ContractEventName<abi>,
+  strict extends boolean | undefined = undefined,
+  chainId extends config['chains'][number]['id'] = config['chains'][number]['id'],
+>(
+  config: config,
+  parameters: UnionEvaluate<
+    UnionOmit<
+      WatchContractEventParameters<abi, name, strict, config, chainId>,
+      omittedProperties
+    >
+  > &
+    (address extends Record<number, Address>
+      ? { chainId?: keyof address | undefined }
+      : unknown),
+) => WatchContractEventReturnType
+
+export function createWatchContractEvent<
+  const abi extends Abi | readonly unknown[],
+  const address extends
+    | Address
+    | Record<number, Address>
+    | undefined = undefined,
+  eventName extends ContractEventName<abi> | undefined = undefined,
+>(
+  c: CreateWatchContractEventParameters<abi, address, eventName>,
+): CreateWatchContractEventReturnType<abi, address, eventName> {
+  if (c.address !== undefined && typeof c.address === 'object')
+    return (config, parameters) => {
+      const configChainId = getChainId(config)
+      const account = getAccount(config)
+      const chainId =
+        (parameters as { chainId?: number })?.chainId ??
+        account.chainId ??
+        configChainId
+      return watchContractEvent(config, {
+        ...(parameters as any),
+        ...(c.eventName ? { functionName: c.eventName } : {}),
+        address: c.address?.[chainId],
+        abi: c.abi,
+      })
+    }
+
+  return (config, parameters) => {
+    return watchContractEvent(config, {
+      ...(parameters as any),
+      ...(c.address ? { address: c.address } : {}),
+      ...(c.eventName ? { functionName: c.eventName } : {}),
+      abi: c.abi,
+    })
+  }
+}

package/src/actions/codegen/createWriteContract.ts

@@ -0,0 +1,142 @@
+import {
+  type Abi,
+  type Account,
+  type Address,
+  type Chain,
+  type ContractFunctionArgs,
+  type ContractFunctionName,
+  type WriteContractParameters as viem_WriteContractParameters,
+} from 'viem'
+
+import { type Config } from '../../createConfig.js'
+import { type SelectChains } from '../../types/chain.js'
+import {
+  type ChainIdParameter,
+  type ConnectorParameter,
+} from '../../types/properties.js'
+import {
+  type Evaluate,
+  type UnionEvaluate,
+  type UnionOmit,
+} from '../../types/utils.js'
+import { getAccount } from '../getAccount.js'
+import { getChainId } from '../getChainId.js'
+import {
+  type WriteContractReturnType,
+  writeContract,
+} from '../writeContract.js'
+
+type stateMutability = 'nonpayable' | 'payable'
+
+export type CreateWriteContractParameters<
+  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 CreateWriteContractReturnType<
+  abi extends Abi | readonly unknown[],
+  address extends Address | Record<number, Address> | undefined,
+  functionName extends ContractFunctionName<abi, stateMutability> | undefined,
+> = <
+  config extends Config,
+  name extends functionName extends ContractFunctionName<abi, stateMutability>
+    ? functionName
+    : ContractFunctionName<abi, stateMutability>,
+  args extends ContractFunctionArgs<abi, stateMutability, name>,
+  chainId extends config['chains'][number]['id'],
+  ///
+  allFunctionNames = ContractFunctionName<abi, 'nonpayable' | 'payable'>,
+  chains extends readonly Chain[] = SelectChains<config, chainId>,
+  omittedProperties extends 'abi' | 'address' | 'functionName' =
+    | 'abi'
+    | (address extends undefined ? never : 'address')
+    | (functionName extends undefined ? never : 'functionName'),
+>(
+  config: config,
+  parameters: 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' }
+  >,
+) => Promise<WriteContractReturnType>
+
+export function createWriteContract<
+  const abi extends Abi | readonly unknown[],
+  const address extends
+    | Address
+    | Record<number, Address>
+    | undefined = undefined,
+  functionName extends
+    | ContractFunctionName<abi, stateMutability>
+    | undefined = undefined,
+>(
+  c: CreateWriteContractParameters<abi, address, functionName>,
+): CreateWriteContractReturnType<abi, address, functionName> {
+  if (c.address !== undefined && typeof c.address === 'object')
+    return (config, parameters) => {
+      const configChainId = getChainId(config)
+      const account = getAccount(config)
+
+      let chainId
+      if (parameters.chainId) chainId = parameters.chainId
+      else if (
+        (parameters as unknown as { account: Address | Account | undefined })
+          .account &&
+        (parameters as unknown as { account: Address | Account | undefined })
+          .account === account.address
+      )
+        chainId = account.chainId
+      else if (
+        (parameters as unknown as { account: Address | Account | undefined })
+          .account === undefined
+      )
+        chainId = account.chainId
+      else chainId = configChainId
+
+      return writeContract(config, {
+        ...(parameters as any),
+        ...(c.functionName ? { functionName: c.functionName } : {}),
+        address: chainId ? c.address?.[chainId] : undefined,
+        abi: c.abi,
+      })
+    }
+
+  return (config, parameters) => {
+    return writeContract(config, {
+      ...(parameters as any),
+      ...(c.address ? { address: c.address } : {}),
+      ...(c.functionName ? { functionName: c.functionName } : {}),
+      abi: c.abi,
+    })
+  }
+}

package/src/actions/connect.ts

@@ -1,17 +1,23 @@
-import { ResourceUnavailableRpcError, UserRejectedRequestError } from 'viem'
-import { type Address } from 'viem'
+import {
+  type Address,
+  type ResourceUnavailableRpcErrorType,
+  type UserRejectedRequestErrorType,
+} from 'viem'
 
+import { type CreateConnectorFn } from '../connectors/createConnector.js'
 import { type Config, type Connector } from '../createConfig.js'
-import { type CreateConnectorFn } from '../createConnector.js'
-import type { BaseError } from '../errors/base.js'
-import { ConnectorAlreadyConnectedError } from '../errors/config.js'
-import type { ChainIdParameter } from '../types/properties.js'
-import type { Evaluate } from '../types/utils.js'
+import type { BaseErrorType, ErrorType } from '../errors/base.js'
+import {
+  ConnectorAlreadyConnectedError,
+  type ConnectorAlreadyConnectedErrorType,
+} from '../errors/config.js'
+import { type ChainIdParameter } from '../types/properties.js'
+import { type Evaluate } from '../types/utils.js'
 
 export type ConnectParameters<config extends Config = Config> = Evaluate<
-  {
+  ChainIdParameter<config> & {
     connector: Connector | CreateConnectorFn
-  } & ChainIdParameter<config>
+  }
 >
 
 export type ConnectReturnType<config extends Config = Config> = {
@@ -21,17 +27,16 @@ export type ConnectReturnType<config extends Config = Config> = {
     | (number extends config['chains'][number]['id'] ? number : number & {})
 }
 
-export type ConnectError =
-  // connect()
-  | ConnectorAlreadyConnectedError
+export type ConnectErrorType =
+  | ConnectorAlreadyConnectedErrorType
   // connector.connect()
-  | UserRejectedRequestError
-  | ResourceUnavailableRpcError
+  | UserRejectedRequestErrorType
+  | ResourceUnavailableRpcErrorType
   // base
-  | BaseError
-  | Error
+  | BaseErrorType
+  | ErrorType
 
-/** https://alpha.wagmi.sh/core/api/actions/connect */
+/** https://wagmi.sh/core/api/actions/connect */
 export async function connect<config extends Config>(
   config: config,
   parameters: ConnectParameters<config>,
@@ -39,7 +44,7 @@ export async function connect<config extends Config>(
   // "Register" connector if not already created
   let connector: Connector
   if (typeof parameters.connector === 'function') {
-    connector = config._internal.setup(parameters.connector)
+    connector = config._internal.connectors.setup(parameters.connector)
   } else connector = parameters.connector
 
   // Check if connector is already connected
@@ -53,9 +58,9 @@ export async function connect<config extends Config>(
     const data = await connector.connect({ chainId: parameters.chainId })
     const accounts = data.accounts as readonly [Address, ...Address[]]
 
-    connector.emitter.off('connect', config._internal.connect)
-    connector.emitter.on('change', config._internal.change)
-    connector.emitter.on('disconnect', config._internal.disconnect)
+    connector.emitter.off('connect', config._internal.events.connect)
+    connector.emitter.on('change', config._internal.events.change)
+    connector.emitter.on('disconnect', config._internal.events.disconnect)
 
     await config.storage?.setItem('recentConnectorId', connector.id)
     config.setState((x) => ({
@@ -69,18 +74,13 @@ export async function connect<config extends Config>(
       status: 'connected',
     }))
 
-    return {
-      accounts,
-      chainId: data.chainId,
-    }
+    return { accounts, chainId: data.chainId }
   } catch (error) {
-    config.setState((x) => {
-      return {
-        ...x,
-        // Keep existing connector connected in case of error
-        status: x.current ? 'connected' : 'disconnected',
-      }
-    })
+    config.setState((x) => ({
+      ...x,
+      // Keep existing connector connected in case of error
+      status: x.current ? 'connected' : 'disconnected',
+    }))
     throw error
   }
 }

package/src/actions/disconnect.ts

@@ -1,22 +1,23 @@
-import {
-  type Config,
-  type Connection,
-  type Connector,
-} from '../createConfig.js'
-import {
-  ConnectorNotConnectedError,
-  ConnectorNotFoundError,
+import type { Config, Connection, Connector } from '../createConfig.js'
+import type { BaseErrorType, ErrorType } from '../errors/base.js'
+import type {
+  ConnectorNotConnectedErrorType,
+  ConnectorNotFoundErrorType,
 } from '../errors/config.js'
+import type { ConnectorParameter } from '../types/properties.js'
 
-export type DisconnectParameters = {
-  connector?: Connector | undefined
-}
+export type DisconnectParameters = ConnectorParameter
 
 export type DisconnectReturnType = void
 
-export type DisconnectError = Error
+export type DisconnectErrorType =
+  | ConnectorNotFoundErrorType
+  | ConnectorNotConnectedErrorType
+  // base
+  | BaseErrorType
+  | ErrorType
 
-/** https://alpha.wagmi.sh/core/api/actions/disconnect */
+/** https://wagmi.sh/core/api/actions/disconnect */
 export async function disconnect(
   config: Config,
   parameters: DisconnectParameters = {},
@@ -29,18 +30,19 @@ export async function disconnect(
     connector = connection?.connector
   }
 
-  if (!connector) throw new ConnectorNotFoundError()
   const connections = config.state.connections
-  if (!connections.has(connector.uid)) throw new ConnectorNotConnectedError()
 
-  await connector.disconnect()
-  connector.emitter.off('change', config._internal.change)
-  connector.emitter.off('disconnect', config._internal.disconnect)
-  connector.emitter.on('connect', config._internal.connect)
+  if (connector) {
+    await connector.disconnect()
+    connector.emitter.off('change', config._internal.events.change)
+    connector.emitter.off('disconnect', config._internal.events.disconnect)
+    connector.emitter.on('connect', config._internal.events.connect)
 
-  connections.delete(connector.uid)
+    connections.delete(connector.uid)
+  }
 
   config.setState((x) => {
+    // if no connections exist, move to disconnected state
     if (connections.size === 0)
       return {
         ...x,
@@ -49,6 +51,7 @@ export async function disconnect(
         status: 'disconnected',
       }
 
+    // switch over to another connection
     const nextConnection = connections.values().next().value as Connection
     return {
       ...x,

package/src/actions/estimateFeesPerGas.ts

@@ -6,15 +6,16 @@ import {
   formatUnits,
 } from 'viem'
 import {
+  type EstimateFeesPerGasErrorType as viem_EstimateFeesPerGasErrorType,
   type EstimateFeesPerGasParameters as viem_EstimateFeesPerGasParameters,
   type EstimateFeesPerGasReturnType as viem_EstimateFeesPerGasReturnType,
   estimateFeesPerGas as viem_estimateFeesPerGas,
 } from 'viem/actions'
 
 import { type Config } from '../createConfig.js'
-import type { ChainIdParameter } from '../types/properties.js'
-import type { Unit } from '../types/unit.js'
-import type { Evaluate } from '../types/utils.js'
+import { type ChainIdParameter } from '../types/properties.js'
+import { type Unit } from '../types/unit.js'
+import { type Evaluate } from '../types/utils.js'
 import type { UnionEvaluate, UnionLooseOmit } from '../types/utils.js'
 import { getUnit } from '../utils/getUnit.js'
 
@@ -27,6 +28,7 @@ export type EstimateFeesPerGasParameters<
     'chain'
   > &
     ChainIdParameter<config> & {
+      /** @deprecated */
       formatUnits?: Unit | undefined
     }
 >
@@ -35,6 +37,7 @@ export type EstimateFeesPerGasReturnType<
   type extends FeeValuesType = FeeValuesType,
 > = Evaluate<
   viem_EstimateFeesPerGasReturnType<type> & {
+    /** @deprecated */
     formatted: UnionEvaluate<
       | (type extends 'legacy' ? FeeValuesLegacy<string> : never)
       | (type extends 'eip1559' ? FeeValuesEIP1559<string> : never)
@@ -42,7 +45,7 @@ export type EstimateFeesPerGasReturnType<
   }
 >
 
-export type EstimateFeesPerGasError = Error
+export type EstimateFeesPerGasErrorType = viem_EstimateFeesPerGasErrorType
 
 export async function estimateFeesPerGas<
   config extends Config,