@wagmi/core 2.5.0 → 2.6.1

package/src/actions/signTypedData.ts

@@ -10,6 +10,7 @@ import { type Config } from '../createConfig.js'
 import type { BaseErrorType, ErrorType } from '../errors/base.js'
 import type { ConnectorParameter } from '../types/properties.js'
 import type { UnionEvaluate } from '../types/utils.js'
+import { getAction } from '../utils/getAction.js'
 import {
   type GetConnectorClientErrorType,
   getConnectorClient,
@@ -46,8 +47,6 @@ export async function signTypedData<
 ): Promise<SignTypedDataReturnType> {
   const { account, connector, ...rest } = parameters
   const client = await getConnectorClient(config, { account, connector })
-  return viem_signTypedData(
-    client,
-    rest as unknown as viem_SignTypedDataParameters,
-  )
+  const action = getAction(client, viem_signTypedData, 'signTypedData')
+  return action(rest as unknown as viem_SignTypedDataParameters)
 }

package/src/actions/simulateContract.ts

@@ -26,6 +26,7 @@ import type {
   UnionEvaluate,
   UnionOmit,
 } from '../types/utils.js'
+import { getAction } from '../utils/getAction.js'
 import {
   type GetConnectorClientErrorType,
   getConnectorClient,
@@ -148,11 +149,8 @@ export async function simulateContract<
   }
 
   const client = config.getClient({ chainId })
-  const { result, request } = await viem_simulateContract(client, {
-    ...rest,
-    abi,
-    account,
-  })
+  const action = getAction(client, viem_simulateContract, 'simulateContract')
+  const { result, request } = await action({ ...rest, abi, account })
 
   return {
     chainId: client.chain.id,

package/src/actions/verifyMessage.ts

@@ -8,6 +8,7 @@ import {
 import { type Config } from '../createConfig.js'
 import { type ChainIdParameter } from '../types/properties.js'
 import { type Evaluate } from '../types/utils.js'
+import { getAction } from '../utils/getAction.js'
 
 export type VerifyMessageParameters<config extends Config = Config> = Evaluate<
   viem_VerifyMessageParameters & ChainIdParameter<config>
@@ -24,5 +25,6 @@ export async function verifyMessage<config extends Config>(
 ): Promise<VerifyMessageReturnType> {
   const { chainId, ...rest } = parameters
   const client = config.getClient({ chainId })
-  return viem_verifyMessage(client, rest)
+  const action = getAction(client, viem_verifyMessage, 'verifyMessage')
+  return action(rest)
 }

package/src/actions/verifyTypedData.ts

@@ -9,6 +9,7 @@ import {
 import { type Config } from '../createConfig.js'
 import { type ChainIdParameter } from '../types/properties.js'
 import { type Evaluate } from '../types/utils.js'
+import { getAction } from '../utils/getAction.js'
 
 export type VerifyTypedDataParameters<
   typedData extends TypedData | Record<string, unknown> = TypedData,
@@ -34,5 +35,6 @@ export async function verifyTypedData<
 ): Promise<VerifyTypedDataReturnType> {
   const { chainId, ...rest } = parameters
   const client = config.getClient({ chainId })
-  return viem_verifyTypedData(client, rest as viem_VerifyTypedDataParameters)
+  const action = getAction(client, viem_verifyTypedData, 'verifyTypedData')
+  return action(rest as viem_VerifyTypedDataParameters)
 }

package/src/actions/waitForTransactionReceipt.ts

@@ -1,4 +1,4 @@
-import type { CallParameters, Chain } from 'viem'
+import { type Chain } from 'viem'
 import { hexToString } from 'viem'
 import {
   type WaitForTransactionReceiptErrorType as viem_WaitForTransactionReceiptErrorType,
@@ -10,9 +10,10 @@ import {
 } from 'viem/actions'
 
 import { type Config } from '../createConfig.js'
-import type { SelectChains } from '../types/chain.js'
+import { type SelectChains } from '../types/chain.js'
 import { type ChainIdParameter } from '../types/properties.js'
 import { type Evaluate, type IsNarrowable } from '../types/utils.js'
+import { getAction } from '../utils/getAction.js'
 
 export type WaitForTransactionReceiptParameters<
   config extends Config = Config,
@@ -47,29 +48,31 @@ export async function waitForTransactionReceipt<
   const { chainId, timeout = 0, ...rest } = parameters
 
   const client = config.getClient({ chainId })
-  const receipt = await viem_waitForTransactionReceipt(client, {
-    ...rest,
-    timeout,
-  })
+  const action = getAction(
+    client,
+    viem_waitForTransactionReceipt,
+    'waitForTransactionReceipt',
+  )
+  const receipt = await action({ ...rest, timeout })
 
   if (receipt.status === 'reverted') {
-    const txn = await getTransaction(client, { hash: receipt.transactionHash })
-    const code = (await call(client, {
+    const action_getTransaction = getAction(
+      client,
+      getTransaction,
+      'getTransaction',
+    )
+    const txn = await action_getTransaction({ hash: receipt.transactionHash })
+    const action_call = getAction(client, call, 'call')
+    const code = (await action_call({
       ...txn,
       gasPrice: txn.type !== 'eip1559' ? txn.gasPrice : undefined,
       maxFeePerGas: txn.type === 'eip1559' ? txn.maxFeePerGas : undefined,
       maxPriorityFeePerGas:
         txn.type === 'eip1559' ? txn.maxPriorityFeePerGas : undefined,
-    } as CallParameters)) as unknown as string
+    })) as unknown as string
     const reason = hexToString(`0x${code.substring(138)}`)
     throw new Error(reason)
   }
 
-  return {
-    ...(receipt as unknown as WaitForTransactionReceiptReturnType<
-      config,
-      chainId
-    >),
-    chainId: client.chain.id,
-  }
+  return { ...receipt, chainId: client.chain.id }
 }

package/src/actions/watchBlockNumber.ts

@@ -12,6 +12,7 @@ import type {
   SyncConnectedChainParameter,
 } from '../types/properties.js'
 import type { UnionEvaluate } from '../types/utils.js'
+import { getAction } from '../utils/getAction.js'
 
 export type WatchBlockNumberParameters<
   config extends Config = Config,
@@ -51,10 +52,8 @@ export function watchBlockNumber<
     if (unwatch) unwatch()
 
     const client = config.getClient({ chainId })
-    unwatch = viem_watchBlockNumber(
-      client,
-      rest as viem_WatchBlockNumberParameters,
-    )
+    const action = getAction(client, viem_watchBlockNumber, 'watchBlockNumber')
+    unwatch = action(rest as viem_WatchBlockNumberParameters)
     return unwatch
   }
 

package/src/actions/watchBlocks.ts

@@ -12,6 +12,7 @@ import type {
   SyncConnectedChainParameter,
 } from '../types/properties.js'
 import type { IsNarrowable, UnionEvaluate } from '../types/utils.js'
+import { getAction } from '../utils/getAction.js'
 
 export type WatchBlocksParameters<
   includeTransactions extends boolean = false,
@@ -63,7 +64,8 @@ export function watchBlocks<
     if (unwatch) unwatch()
 
     const client = config.getClient({ chainId })
-    unwatch = viem_watchBlocks(client, rest as viem_WatchBlocksParameters)
+    const action = getAction(client, viem_watchBlocks, 'watchBlocks')
+    unwatch = action(rest as viem_WatchBlocksParameters)
     return unwatch
   }
 

package/src/actions/watchContractEvent.ts

@@ -18,6 +18,7 @@ import {
   type SyncConnectedChainParameter,
 } from '../types/properties.js'
 import { type UnionEvaluate } from '../types/utils.js'
+import { getAction } from '../utils/getAction.js'
 
 export type WatchContractEventParameters<
   abi extends Abi | readonly unknown[] = Abi,
@@ -72,10 +73,12 @@ export function watchContractEvent<
     if (unwatch) unwatch()
 
     const client = config.getClient({ chainId })
-    unwatch = viem_watchContractEvent(
+    const action = getAction(
       client,
-      rest as unknown as viem_WatchContractEventParameters,
+      viem_watchContractEvent,
+      'watchContractEvent',
     )
+    unwatch = action(rest as unknown as viem_WatchContractEventParameters)
     return unwatch
   }
 

package/src/actions/watchPendingTransactions.ts

@@ -12,6 +12,7 @@ import type {
   SyncConnectedChainParameter,
 } from '../types/properties.js'
 import type { UnionEvaluate } from '../types/utils.js'
+import { getAction } from '../utils/getAction.js'
 
 export type WatchPendingTransactionsParameters<
   config extends Config = Config,
@@ -52,10 +53,12 @@ export function watchPendingTransactions<
     if (unwatch) unwatch()
 
     const client = config.getClient({ chainId })
-    unwatch = viem_watchPendingTransactions(
+    const action = getAction(
       client,
-      rest as viem_WatchPendingTransactionsParameters,
+      viem_watchPendingTransactions,
+      'watchPendingTransactions',
     )
+    unwatch = action(rest as viem_WatchPendingTransactionsParameters)
     return unwatch
   }
 

package/src/actions/writeContract.ts

@@ -20,6 +20,7 @@ import {
   type ConnectorParameter,
 } from '../types/properties.js'
 import type { Evaluate, UnionEvaluate, UnionOmit } from '../types/utils.js'
+import { getAction } from '../utils/getAction.js'
 import {
   type GetConnectorClientErrorType,
   getConnectorClient,
@@ -110,7 +111,8 @@ export async function writeContract<
     request = simulateRequest
   }
 
-  const hash = await viem_writeContract(client, {
+  const action = getAction(client, viem_writeContract, 'writeContract')
+  const hash = await action({
     ...(request as any),
     chain: chainId ? { id: chainId } : null,
   })

package/src/connectors/injected.ts

@@ -157,7 +157,9 @@ export function injected(parameters: InjectedParameters = {}) {
               method: 'wallet_requestPermissions',
               params: [{ eth_accounts: {} }],
             })
-            accounts = permissions[0]?.caveats?.[0]?.value?.map(getAddress)
+            accounts = (permissions[0]?.caveats?.[0]?.value as string[])?.map(
+              (x) => getAddress(x),
+            )
           } catch (err) {
             const error = err as RpcError
             // Not all injected providers support `wallet_requestPermissions` (e.g. MetaMask iOS).
@@ -174,7 +176,7 @@ export function injected(parameters: InjectedParameters = {}) {
           const requestedAccounts = await provider.request({
             method: 'eth_requestAccounts',
           })
-          accounts = requestedAccounts.map(getAddress)
+          accounts = requestedAccounts.map((x) => getAddress(x))
         }
 
         provider.removeListener('connect', this.onConnect.bind(this))
@@ -233,7 +235,7 @@ export function injected(parameters: InjectedParameters = {}) {
       const provider = await this.getProvider()
       if (!provider) throw new ProviderNotFoundError()
       const accounts = await provider.request({ method: 'eth_accounts' })
-      return accounts.map(getAddress)
+      return accounts.map((x) => getAddress(x))
     },
     async getChainId() {
       const provider = await this.getProvider()
@@ -405,7 +407,10 @@ export function injected(parameters: InjectedParameters = {}) {
           await config.storage?.removeItem(`${this.id}.disconnected`)
       }
       // Regular change event
-      else config.emitter.emit('change', { accounts: accounts.map(getAddress) })
+      else
+        config.emitter.emit('change', {
+          accounts: accounts.map((x) => getAddress(x)),
+        })
     },
     onChainChanged(chain) {
       const chainId = normalizeChainId(chain)

package/src/connectors/mock.ts

@@ -80,7 +80,7 @@ export function mock(parameters: MockParameters) {
       if (!connected) throw new ConnectorNotConnectedError()
       const provider = await this.getProvider()
       const accounts = await provider.request({ method: 'eth_accounts' })
-      return accounts.map(getAddress)
+      return accounts.map((x) => getAddress(x))
     },
     async getChainId() {
       const provider = await this.getProvider()
@@ -106,7 +106,10 @@ export function mock(parameters: MockParameters) {
     },
     onAccountsChanged(accounts) {
       if (accounts.length === 0) this.onDisconnect()
-      else config.emitter.emit('change', { accounts: accounts.map(getAddress) })
+      else
+        config.emitter.emit('change', {
+          accounts: accounts.map((x) => getAddress(x)),
+        })
     },
     onChainChanged(chain) {
       const chainId = normalizeChainId(chain)

package/src/createConfig.ts

@@ -109,10 +109,9 @@ export function createConfig<
     return connector
   }
   function providerDetailToConnector(providerDetail: EIP6963ProviderDetail) {
-    const { info, provider } = providerDetail
-    return injected({
-      target: { ...info, id: info.rdns, provider: provider as any },
-    })
+    const { info } = providerDetail
+    const provider = providerDetail.provider as any
+    return injected({ target: { ...info, id: info.rdns, provider } })
   }
 
   const clients = new Map<number, Client<Transport, chains[number]>>()
@@ -122,6 +121,9 @@ export function createConfig<
     const chainId = config.chainId ?? store.getState().chainId
     const chain = chains.find((x) => x.id === chainId)
 
+    // chainId specified and not configured
+    if (config.chainId && !chain) throw new ChainNotConfiguredError()
+
     // If the target chain is not configured, use the client of the current chain.
     type Return = Client<Transport, Extract<chains[number], { id: chainId }>>
     {
@@ -156,10 +158,7 @@ export function createConfig<
         chain,
         batch: properties.batch ?? { multicall: true },
         transport: (parameters) =>
-          rest.transports[chainId]({
-            ...parameters,
-            connectors,
-          }),
+          rest.transports[chainId]({ ...parameters, connectors }),
       })
     }
 
@@ -192,13 +191,8 @@ export function createConfig<
                   value: Array.from(state.connections.entries()).map(
                     ([key, connection]) => {
                       const { id, name, type, uid } = connection.connector
-                      return [
-                        key,
-                        {
-                          ...connection,
-                          connector: { id, name, type, uid },
-                        },
-                      ]
+                      const connector = { id, name, type, uid }
+                      return [key, { ...connection, connector }]
                     },
                   ),
                 } as unknown as PartializedState['connections'],

package/src/utils/getAction.ts

@@ -0,0 +1,38 @@
+import {
+  type Account,
+  type Chain,
+  type Client,
+  type PublicActions,
+  type RpcSchema,
+  type Transport,
+  type WalletActions,
+} from 'viem'
+
+/**
+ * Retrieves and returns an action from the client (if exists), and falls
+ * back to the tree-shakable action.
+ *
+ * Useful for extracting overridden actions from a client (ie. if a consumer
+ * wants to override the `sendTransaction` implementation).
+ */
+export function getAction<
+  transport extends Transport,
+  chain extends Chain | undefined,
+  account extends Account | undefined,
+  rpcSchema extends RpcSchema | undefined,
+  extended extends { [key: string]: unknown },
+  client extends Client<transport, chain, account, rpcSchema, extended>,
+  parameters,
+  returnType,
+>(
+  client: client,
+  actionFn: (_: any, parameters: parameters) => returnType,
+  // Some minifiers drop `Function.prototype.name`, meaning that `action.name`
+  // will not work. For that case, the consumer needs to pass the name explicitly.
+  name: keyof PublicActions | keyof WalletActions,
+): (parameters: parameters) => returnType {
+  const action = client[actionFn.name ?? name]
+  if (typeof action === 'function')
+    return action as (params: parameters) => returnType
+  return (params) => actionFn(client, params)
+}

package/src/version.ts

@@ -1 +1 @@
-export const version = '2.5.0'
+export const version = '2.6.1'