@wagmi/core 2.0.0 → 2.0.2

package/src/actions/getFeeHistory.ts

@@ -0,0 +1,32 @@
+import {
+  type GetFeeHistoryErrorType as viem_GetFeeHistoryErrorType,
+  type GetFeeHistoryParameters as viem_GetFeeHistoryParameters,
+  type GetFeeHistoryReturnType as viem_GetFeeHistoryReturnType,
+  getFeeHistory as viem_getFeeHistory,
+} from 'viem/actions'
+
+import { type Config } from '../createConfig.js'
+import { type ChainIdParameter } from '../types/properties.js'
+import { type Evaluate } from '../types/utils.js'
+
+export type GetFeeHistoryParameters<
+  config extends Config = Config,
+  chainId extends config['chains'][number]['id'] = config['chains'][number]['id'],
+> = Evaluate<viem_GetFeeHistoryParameters & ChainIdParameter<config, chainId>>
+
+export type GetFeeHistoryReturnType = viem_GetFeeHistoryReturnType
+
+export type GetFeeHistoryErrorType = viem_GetFeeHistoryErrorType
+
+/** https://wagmi.sh/core/api/actions/getFeeHistory */
+export function getFeeHistory<
+  config extends Config,
+  chainId extends config['chains'][number]['id'] = config['chains'][number]['id'],
+>(
+  config: config,
+  parameters: GetFeeHistoryParameters<config, chainId>,
+): Promise<GetFeeHistoryReturnType> {
+  const { chainId } = parameters
+  const client = config.getClient({ chainId })
+  return viem_getFeeHistory(client, parameters)
+}

package/src/actions/getGasPrice.ts

@@ -0,0 +1,31 @@
+import {
+  type GetGasPriceErrorType as viem_GetGasPriceErrorType,
+  type GetGasPriceReturnType as viem_GetGasPriceReturnType,
+  getGasPrice as viem_getGasPrice,
+} from 'viem/actions'
+
+import { type Config } from '../createConfig.js'
+import { type ChainIdParameter } from '../types/properties.js'
+import { type Evaluate } from '../types/utils.js'
+
+export type GetGasPriceParameters<
+  config extends Config = Config,
+  chainId extends config['chains'][number]['id'] = config['chains'][number]['id'],
+> = Evaluate<ChainIdParameter<config, chainId>>
+
+export type GetGasPriceReturnType = viem_GetGasPriceReturnType
+
+export type GetGasPriceErrorType = viem_GetGasPriceErrorType
+
+/** https://wagmi.sh/core/api/actions/getGasPrice */
+export function getGasPrice<
+  config extends Config,
+  chainId extends config['chains'][number]['id'] = config['chains'][number]['id'],
+>(
+  config: config,
+  parameters: GetGasPriceParameters<config, chainId> = {},
+): Promise<GetGasPriceReturnType> {
+  const { chainId } = parameters
+  const client = config.getClient({ chainId })
+  return viem_getGasPrice(client)
+}

package/src/actions/getPublicClient.ts

@@ -1,8 +1,8 @@
 import { type PublicClient, publicActions } from 'viem'
 
-import type { Config } from '../createConfig.js'
-import type { ChainIdParameter } from '../types/properties.js'
-import type { Evaluate } from '../types/utils.js'
+import { type Config } from '../createConfig.js'
+import { type ChainIdParameter } from '../types/properties.js'
+import { type Evaluate } from '../types/utils.js'
 
 export type GetPublicClientParameters<
   config extends Config = Config,

package/src/actions/getToken.ts

@@ -6,18 +6,18 @@ import {
   trim,
 } from 'viem'
 
-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 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 { getUnit } from '../utils/getUnit.js'
-import { readContracts } from './readContracts.js'
+import { type ReadContractsErrorType, readContracts } from './readContracts.js'
 
 export type GetTokenParameters<config extends Config = Config> = Evaluate<
-  {
+  ChainIdParameter<config> & {
     address: Address
-    formatUnits?: Unit
-  } & ChainIdParameter<config>
+    formatUnits?: Unit | undefined
+  }
 >
 
 export type GetTokenReturnType = {
@@ -31,8 +31,9 @@ export type GetTokenReturnType = {
   }
 }
 
-export type GetTokenError = Error
+export type GetTokenErrorType = ReadContractsErrorType
 
+/** @deprecated */
 export async function getToken<config extends Config>(
   config: config,
   parameters: GetTokenParameters<config>,

package/src/actions/getTransaction.ts

@@ -1,5 +1,6 @@
 import type { Chain } from 'viem'
 import {
+  type GetTransactionErrorType as viem_GetTransactionErrorType,
   type GetTransactionParameters as viem_GetTransactionParameters,
   type GetTransactionReturnType as viem_GetTransactionReturnType,
   getTransaction as viem_getTransaction,
@@ -7,8 +8,8 @@ import {
 
 import { type Config } from '../createConfig.js'
 import type { SelectChains } from '../types/chain.js'
-import type { ChainIdParameter } from '../types/properties.js'
-import { type Evaluate } from '../types/utils.js'
+import { type ChainIdParameter } from '../types/properties.js'
+import { type Evaluate, type IsNarrowable } from '../types/utils.js'
 
 export type GetTransactionParameters<
   config extends Config = Config,
@@ -22,13 +23,15 @@ export type GetTransactionReturnType<
   chains extends readonly Chain[] = SelectChains<config, chainId>,
 > = Evaluate<
   {
-    [key in keyof chains]: viem_GetTransactionReturnType<chains[key]>
+    [key in keyof chains]: viem_GetTransactionReturnType<
+      IsNarrowable<chains[key], Chain> extends true ? chains[key] : undefined
+    > & { chainId: chains[key]['id'] }
   }[number]
 >
 
-export type GetTransactionError = Error
+export type GetTransactionErrorType = viem_GetTransactionErrorType
 
-/** https://alpha.wagmi.sh/core/api/actions/getTransaction */
+/** https://wagmi.sh/core/api/actions/getTransaction */
 export function getTransaction<
   config extends Config,
   chainId extends config['chains'][number]['id'],

package/src/actions/getTransactionCount.ts

@@ -0,0 +1,31 @@
+import {
+  type GetTransactionCountErrorType as viem_GetTransactionCountErrorType,
+  type GetTransactionCountParameters as viem_GetTransactionCountParameters,
+  type GetTransactionCountReturnType as viem_GetTransactionCountReturnType,
+  getTransactionCount as viem_getTransactionCount,
+} from 'viem/actions'
+
+import { type Config } from '../createConfig.js'
+import { type ChainIdParameter } from '../types/properties.js'
+import { type Evaluate } from '../types/utils.js'
+
+export type GetTransactionCountParameters<config extends Config = Config> =
+  Evaluate<ChainIdParameter<config> & viem_GetTransactionCountParameters>
+
+export type GetTransactionCountReturnType = viem_GetTransactionCountReturnType
+
+export type GetTransactionCountErrorType = viem_GetTransactionCountErrorType
+
+/** https://wagmi.sh/core/api/actions/getTransactionCount */
+export async function getTransactionCount<config extends Config>(
+  config: config,
+  parameters: GetTransactionCountParameters<config>,
+): Promise<GetTransactionCountReturnType> {
+  const { address, blockNumber, blockTag, chainId } = parameters
+
+  const client = config.getClient({ chainId })
+  return await viem_getTransactionCount(
+    client,
+    blockNumber ? { address, blockNumber } : { address, blockTag },
+  )
+}

package/src/actions/getWalletClient.ts

@@ -1,9 +1,10 @@
 import { type Account, type WalletClient, walletActions } from 'viem'
 
-import type { Config } from '../createConfig.js'
-import type { Evaluate } from '../types/utils.js'
+import { type Config } from '../createConfig.js'
+import type { BaseErrorType, ErrorType } from '../errors/base.js'
+import { type Evaluate } from '../types/utils.js'
 import {
-  type GetConnectorClientError,
+  type GetConnectorClientErrorType,
   type GetConnectorClientParameters,
   getConnectorClient,
 } from './getConnectorClient.js'
@@ -24,7 +25,12 @@ export type GetWalletClientReturnType<
   >
 >
 
-export type GetWalletClientError = GetConnectorClientError
+export type GetWalletClientErrorType =
+  // getConnectorClient()
+  | GetConnectorClientErrorType
+  // base
+  | BaseErrorType
+  | ErrorType
 
 export async function getWalletClient<
   config extends Config,
@@ -34,6 +40,9 @@ export async function getWalletClient<
   parameters: GetWalletClientParameters<config, chainId> = {},
 ): Promise<GetWalletClientReturnType<config, chainId>> {
   const client = await getConnectorClient(config, parameters)
+  client.extend(walletActions)
+
+  // @ts-ignore
   return client.extend(walletActions) as unknown as GetWalletClientReturnType<
     config,
     chainId

package/src/actions/multicall.ts

@@ -1,12 +1,13 @@
 import type {
   ContractFunctionParameters,
+  MulticallErrorType as viem_MulticallErrorType,
   MulticallParameters as viem_MulticallParameters,
   MulticallReturnType as viem_MulticallReturnType,
 } from 'viem'
 import { multicall as viem_multicall } from 'viem/actions'
 
-import type { Config } from '../createConfig.js'
-import type { ChainIdParameter } from '../types/properties.js'
+import { type Config } from '../createConfig.js'
+import { type ChainIdParameter } from '../types/properties.js'
 
 export type MulticallParameters<
   contracts extends readonly unknown[] = readonly ContractFunctionParameters[],
@@ -19,9 +20,11 @@ export type MulticallReturnType<
   allowFailure extends boolean = true,
 > = viem_MulticallReturnType<contracts, allowFailure>
 
+export type MulticallErrorType = viem_MulticallErrorType
+
 export async function multicall<
   config extends Config,
-  const contracts extends readonly unknown[],
+  const contracts extends readonly ContractFunctionParameters[],
   allowFailure extends boolean = true,
 >(
   config: config,

package/src/actions/readContract.ts

@@ -1,13 +1,14 @@
 import { type Abi } from 'viem'
 import type { ContractFunctionArgs, ContractFunctionName } from 'viem'
 import {
+  type ReadContractErrorType as viem_ReadContractErrorType,
   type ReadContractParameters as viem_ReadContractParameters,
   type ReadContractReturnType as viem_ReadContractReturnType,
   readContract as viem_readContract,
 } from 'viem/actions'
 
 import { type Config } from '../createConfig.js'
-import type { ChainIdParameter } from '../types/properties.js'
+import { type ChainIdParameter } from '../types/properties.js'
 
 export type ReadContractParameters<
   abi extends Abi | readonly unknown[] = Abi,
@@ -37,9 +38,9 @@ export type ReadContractReturnType<
   > = ContractFunctionArgs<abi, 'pure' | 'view', functionName>,
 > = viem_ReadContractReturnType<abi, functionName, args>
 
-export type ReadContractError = Error
+export type ReadContractErrorType = viem_ReadContractErrorType
 
-/** https://alpha.wagmi.sh/core/api/actions/readContract */
+/** https://wagmi.sh/core/api/actions/readContract */
 export function readContract<
   config extends Config,
   const abi extends Abi | readonly unknown[],

package/src/actions/readContracts.ts

@@ -7,8 +7,8 @@ import { ContractFunctionExecutionError } from 'viem'
 
 import { type Config } from '../createConfig.js'
 import { type ChainIdParameter } from '../types/properties.js'
-import { multicall } from './multicall.js'
-import { readContract } from './readContract.js'
+import { type MulticallErrorType, multicall } from './multicall.js'
+import { type ReadContractErrorType, readContract } from './readContract.js'
 
 export type ReadContractsParameters<
   contracts extends readonly unknown[] = readonly ContractFunctionParameters[],
@@ -25,7 +25,7 @@ export type ReadContractsReturnType<
   allowFailure extends boolean = true,
 > = viem_MulticallReturnType<contracts, allowFailure>
 
-export type ReadContractsError = Error
+export type ReadContractsErrorType = MulticallErrorType | ReadContractErrorType
 
 export async function readContracts<
   config extends Config,
@@ -73,7 +73,7 @@ export async function readContracts<
       (contracts) => contracts.map(({ index }) => index),
     )
     return multicallResults.reduce((results, result, index) => {
-      if (results) results[resultIndexes[index]!] = result
+      if (results) (results as unknown[])[resultIndexes[index]!] = result
       return results
     }, [] as unknown[]) as ReadContractsReturnType<contracts, allowFailure>
   } catch (error) {

package/src/actions/reconnect.ts

@@ -1,8 +1,9 @@
-import type { Address } from 'viem'
+import { type Address } from 'viem'
 
+import { type CreateConnectorFn } from '../connectors/createConnector.js'
 import type { Config, Connection, Connector } from '../createConfig.js'
-import { type CreateConnectorFn } from '../createConnector.js'
-import type { Evaluate } from '../types/utils.js'
+import type { ErrorType } from '../errors/base.js'
+import { type Evaluate } from '../types/utils.js'
 
 export type ReconnectParameters = {
   /** Connectors to attempt reconnect with */
@@ -11,11 +12,11 @@ export type ReconnectParameters = {
 
 export type ReconnectReturnType = Evaluate<Connection>[]
 
-export type ReconnectError = Error
+export type ReconnectErrorType = ErrorType
 
 let isReconnecting = false
 
-/** https://alpha.wagmi.sh/core/api/actions/reconnect */
+/** https://wagmi.sh/core/api/actions/reconnect */
 export async function reconnect(
   config: Config,
   parameters: ReconnectParameters = {},
@@ -35,7 +36,7 @@ export async function reconnect(
       let connector: Connector
       // "Register" connector if not already created
       if (typeof connector_ === 'function')
-        connector = config._internal.setup(connector_)
+        connector = config._internal.connectors.setup(connector_)
       else connector = connector_
       connectors.push(connector)
     }
@@ -63,10 +64,14 @@ export async function reconnect(
     const isAuthorized = await connector.isAuthorized()
     if (!isAuthorized) continue
 
-    const data = await connector.connect()
-    connector.emitter.off('connect', config._internal.connect)
-    connector.emitter.on('change', config._internal.change)
-    connector.emitter.on('disconnect', config._internal.disconnect)
+    const data = await connector
+      .connect({ isReconnecting: true })
+      .catch(() => null)
+    if (!data) continue
+
+    connector.emitter.off('connect', config._internal.events.connect)
+    connector.emitter.on('change', config._internal.events.change)
+    connector.emitter.on('disconnect', config._internal.events.disconnect)
 
     config.setState((x) => {
       const connections = new Map(connected ? x.connections : new Map()).set(

package/src/actions/sendTransaction.ts

@@ -2,20 +2,24 @@ import type {
   Account,
   Address,
   Chain,
+  SendTransactionErrorType as viem_SendTransactionErrorType,
   SendTransactionParameters as viem_SendTransactionParameters,
   SendTransactionReturnType as viem_SendTransactionReturnType,
 } from 'viem'
 import { sendTransaction as viem_sendTransaction } from 'viem/actions'
 
-import type { Config } from '../createConfig.js'
+import { type Config } from '../createConfig.js'
+import type { BaseErrorType, ErrorType } from '../errors/base.js'
 import type { SelectChains } from '../types/chain.js'
 import type {
   ChainIdParameter,
   ConnectorParameter,
 } from '../types/properties.js'
-import type { Evaluate } from '../types/utils.js'
-import { assertActiveChain } from '../utils/assertActiveChain.js'
-import { getConnectorClient } from './getConnectorClient.js'
+import { type Evaluate } from '../types/utils.js'
+import {
+  type GetConnectorClientErrorType,
+  getConnectorClient,
+} from './getConnectorClient.js'
 
 export type SendTransactionParameters<
   config extends Config = Config,
@@ -37,9 +41,16 @@ export type SendTransactionParameters<
 
 export type SendTransactionReturnType = viem_SendTransactionReturnType
 
-export type SendTransactionError = Error
+export type SendTransactionErrorType =
+  // getConnectorClient()
+  | GetConnectorClientErrorType
+  // base
+  | BaseErrorType
+  | ErrorType
+  // viem
+  | viem_SendTransactionErrorType
 
-/** https://alpha.wagmi.sh/core/api/actions/sendTransaction */
+/** https://wagmi.sh/core/api/actions/sendTransaction */
 export async function sendTransaction<
   config extends Config,
   chainId extends config['chains'][number]['id'],
@@ -54,15 +65,11 @@ export async function sendTransaction<
     chainId,
     connector,
   })
-  if (chainId)
-    assertActiveChain(config, { activeChainId: client.chain.id, chainId })
 
   const hash = await viem_sendTransaction(client, {
-    ...(rest as unknown as viem_SendTransactionParameters),
-    // Setting to `null` to not validate inside `viem_sendTransaction`
-    // since we already validated above
-    chain: null,
-  } as viem_SendTransactionParameters)
+    ...(rest as any),
+    chain: chainId ? { id: chainId } : null,
+  })
 
   return hash
 }

package/src/actions/signMessage.ts

@@ -1,14 +1,19 @@
-import type { Account } from 'viem'
+import { type Account } from 'viem'
 import {
+  type SignMessageErrorType as viem_SignMessageErrorType,
   type SignMessageParameters as viem_SignMessageParameters,
   type SignMessageReturnType as viem_SignMessageReturnType,
   signMessage as viem_signMessage,
 } from 'viem/actions'
 
 import { type Config } from '../createConfig.js'
+import type { BaseErrorType, ErrorType } from '../errors/base.js'
 import type { ConnectorParameter } from '../types/properties.js'
-import type { Evaluate } from '../types/utils.js'
-import { getConnectorClient } from './getConnectorClient.js'
+import { type Evaluate } from '../types/utils.js'
+import {
+  type GetConnectorClientErrorType,
+  getConnectorClient,
+} from './getConnectorClient.js'
 
 export type SignMessageParameters = Evaluate<
   viem_SignMessageParameters<Account> & ConnectorParameter
@@ -16,9 +21,16 @@ export type SignMessageParameters = Evaluate<
 
 export type SignMessageReturnType = viem_SignMessageReturnType
 
-export type SignMessageError = Error
+export type SignMessageErrorType =
+  // getConnectorClient()
+  | GetConnectorClientErrorType
+  // base
+  | BaseErrorType
+  | ErrorType
+  // viem
+  | viem_SignMessageErrorType
 
-/** https://alpha.wagmi.sh/core/api/actions/signMessage */
+/** https://wagmi.sh/core/api/actions/signMessage */
 export async function signMessage(
   config: Config,
   parameters: SignMessageParameters,

package/src/actions/signTypedData.ts

@@ -1,25 +1,42 @@
 import type { Account, TypedData } from 'viem'
 import {
+  type SignMessageErrorType as viem_SignMessageErrorType,
   type SignTypedDataParameters as viem_SignTypedDataParameters,
   type SignTypedDataReturnType as viem_SignTypedDataReturnType,
   signTypedData as viem_signTypedData,
 } from 'viem/actions'
 
 import { type Config } from '../createConfig.js'
+import type { BaseErrorType, ErrorType } from '../errors/base.js'
 import type { ConnectorParameter } from '../types/properties.js'
-import { getConnectorClient } from './getConnectorClient.js'
+import type { UnionEvaluate } from '../types/utils.js'
+import {
+  type GetConnectorClientErrorType,
+  getConnectorClient,
+} from './getConnectorClient.js'
 
 export type SignTypedDataParameters<
   typedData extends TypedData | Record<string, unknown> = TypedData,
   primaryType extends keyof typedData | 'EIP712Domain' = keyof typedData,
-> = viem_SignTypedDataParameters<typedData, primaryType, Account> &
-  ConnectorParameter
+  ///
+  primaryTypes = typedData extends TypedData ? keyof typedData : string,
+> = UnionEvaluate<
+  viem_SignTypedDataParameters<typedData, primaryType, Account, primaryTypes> &
+    ConnectorParameter
+>
 
 export type SignTypedDataReturnType = viem_SignTypedDataReturnType
 
-export type SignTypedDataError = Error
+export type SignTypedDataErrorType =
+  // getConnectorClient()
+  | GetConnectorClientErrorType
+  // base
+  | BaseErrorType
+  | ErrorType
+  // viem
+  | viem_SignMessageErrorType
 
-/** https://alpha.wagmi.sh/core/api/actions/signTypedData */
+/** https://wagmi.sh/core/api/actions/signTypedData */
 export async function signTypedData<
   const typedData extends TypedData | Record<string, unknown>,
   primaryType extends keyof typedData | 'EIP712Domain',

package/src/actions/simulateContract.ts

@@ -7,20 +7,29 @@ import type {
   ContractFunctionName,
 } from 'viem'
 import {
+  type SimulateContractErrorType as viem_SimulateContractErrorType,
   type SimulateContractParameters as viem_SimulateContractParameters,
   type SimulateContractReturnType as viem_SimulateContractReturnType,
   simulateContract as viem_simulateContract,
 } from 'viem/actions'
 
 import { type Config } from '../createConfig.js'
-import type { SelectChains } from '../types/chain.js'
-import type {
-  ChainIdParameter,
-  ConnectorParameter,
+import { type BaseErrorType, type ErrorType } from '../errors/base.js'
+import { type SelectChains } from '../types/chain.js'
+import {
+  type ChainIdParameter,
+  type ConnectorParameter,
 } from '../types/properties.js'
-import type { PartialBy, UnionEvaluate, UnionOmit } from '../types/utils.js'
-import { assertActiveChain } from '../utils/assertActiveChain.js'
-import { getConnectorClient } from './getConnectorClient.js'
+import type {
+  Evaluate,
+  PartialBy,
+  UnionEvaluate,
+  UnionOmit,
+} from '../types/utils.js'
+import {
+  type GetConnectorClientErrorType,
+  getConnectorClient,
+} from './getConnectorClient.js'
 
 export type SimulateContractParameters<
   abi extends Abi | readonly unknown[] = Abi,
@@ -47,7 +56,8 @@ export type SimulateContractParameters<
         functionName,
         args,
         chains[key],
-        chains[key]
+        chains[key],
+        Account | Address
       >,
       'chain'
     >
@@ -78,31 +88,30 @@ export type SimulateContractReturnType<
     abi,
     functionName,
     args,
+    chains[key],
+    Account,
     chains[key]
-  > extends infer type extends viem_SimulateContractReturnType<
-    abi,
-    functionName,
-    args
-  >
-    ? UnionEvaluate<
-        UnionOmit<type, 'request'> & {
-          request: UnionEvaluate<
-            UnionOmit<type['request'], 'chain'> &
-              PartialBy<
-                { __mode: 'prepared'; chainId: chainId },
-                chainId extends config['chains'][number]['id']
-                  ? never
-                  : 'chainId'
-              >
-          >
-        }
+  > & {
+    chainId: chains[key]['id']
+    request: Evaluate<
+      PartialBy<
+        { __mode: 'prepared'; chainId: chainId; chain: chains[key] },
+        chainId extends config['chains'][number]['id'] ? never : 'chainId'
       >
-    : never
+    >
+  }
 }[number]
 
-export type SimulateContractError = Error
+export type SimulateContractErrorType =
+  // getConnectorClient()
+  | GetConnectorClientErrorType
+  // base
+  | BaseErrorType
+  | ErrorType
+  // viem
+  | viem_SimulateContractErrorType
 
-/** https://alpha.wagmi.sh/core/api/actions/simulateContract */
+/** https://wagmi.sh/core/api/actions/simulateContract */
 export async function simulateContract<
   config extends Config,
   const abi extends Abi | readonly unknown[],
@@ -129,7 +138,6 @@ export async function simulateContract<
     parameters as SimulateContractParameters
 
   let account: Address | Account
-  let activeChainId: number | undefined
   if (parameters.account) account = parameters.account
   else {
     const connectorClient = await getConnectorClient(config, {
@@ -137,9 +145,7 @@ export async function simulateContract<
       connector,
     })
     account = connectorClient.account
-    activeChainId = connectorClient.chain.id
   }
-  if (chainId) assertActiveChain(config, { activeChainId, chainId })
 
   const client = config.getClient({ chainId })
   const { result, request } = await viem_simulateContract(client, {
@@ -149,6 +155,7 @@ export async function simulateContract<
   })
 
   return {
+    chainId: client.chain.id,
     result,
     request: { __mode: 'prepared', ...request, chainId },
   } as unknown as SimulateContractReturnType<