viem 2.17.2 → 2.17.4

package/actions/public/verifyHash.ts

@@ -13,6 +13,8 @@ import {
   type EncodeDeployDataErrorType,
   encodeDeployData,
 } from '../../utils/abi/encodeDeployData.js'
+import { getAddress } from '../../utils/address/getAddress.js'
+import { isAddressEqual } from '../../utils/address/isAddressEqual.js'
 import {
   type IsBytesEqualErrorType,
   isBytesEqual,
@@ -21,6 +23,7 @@ import { type IsHexErrorType, isHex } from '../../utils/data/isHex.js'
 import { type ToHexErrorType, bytesToHex } from '../../utils/encoding/toHex.js'
 import { getAction } from '../../utils/getAction.js'
 import { isErc6492Signature } from '../../utils/signature/isErc6492Signature.js'
+import { recoverAddress } from '../../utils/signature/recoverAddress.js'
 import { serializeErc6492Signature } from '../../utils/signature/serializeErc6492Signature.js'
 import { serializeSignature } from '../../utils/signature/serializeSignature.js'
 import { type CallErrorType, type CallParameters, call } from './call.js'
@@ -55,8 +58,8 @@ export type VerifyHashErrorType =
  * @param parameters - {@link VerifyHashParameters}
  * @returns Whether or not the signature is valid. {@link VerifyHashReturnType}
  */
-export async function verifyHash<TChain extends Chain | undefined>(
-  client: Client<Transport, TChain>,
+export async function verifyHash<chain extends Chain | undefined>(
+  client: Client<Transport, chain>,
   parameters: VerifyHashParameters,
 ): Promise<VerifyHashReturnType> {
   const { address, factory, factoryData, hash, signature, ...rest } = parameters
@@ -105,6 +108,15 @@ export async function verifyHash<TChain extends Chain | undefined>(
 
     return isBytesEqual(data ?? '0x0', '0x1')
   } catch (error) {
+    // Fallback attempt to verify the signature via ECDSA recovery.
+    try {
+      const verified = isAddressEqual(
+        getAddress(address),
+        await recoverAddress({ hash, signature }),
+      )
+      if (verified) return true
+    } catch {}
+
     if (error instanceof CallExecutionError) {
       // if the execution fails, the signature was not valid and an internal method inside of the validator reverted
       // this can happen for many reasons, for example if signer can not be recovered from the signature

package/actions/public/verifyMessage.ts

@@ -48,8 +48,8 @@ export type VerifyMessageErrorType =
  * @param parameters - {@link VerifyMessageParameters}
  * @returns Whether or not the signature is valid. {@link VerifyMessageReturnType}
  */
-export async function verifyMessage<TChain extends Chain | undefined>(
-  client: Client<Transport, TChain>,
+export async function verifyMessage<chain extends Chain | undefined>(
+  client: Client<Transport, chain>,
   {
     address,
     message,

package/actions/public/waitForTransactionReceipt.ts

@@ -36,20 +36,20 @@ import {
 
 export type ReplacementReason = 'cancelled' | 'replaced' | 'repriced'
 export type ReplacementReturnType<
-  TChain extends Chain | undefined = Chain | undefined,
+  chain extends Chain | undefined = Chain | undefined,
 > = {
   reason: ReplacementReason
   replacedTransaction: Transaction
   transaction: Transaction
-  transactionReceipt: GetTransactionReceiptReturnType<TChain>
+  transactionReceipt: GetTransactionReceiptReturnType<chain>
 }
 
 export type WaitForTransactionReceiptReturnType<
-  TChain extends Chain | undefined = Chain | undefined,
-> = GetTransactionReceiptReturnType<TChain>
+  chain extends Chain | undefined = Chain | undefined,
+> = GetTransactionReceiptReturnType<chain>
 
 export type WaitForTransactionReceiptParameters<
-  TChain extends Chain | undefined = Chain | undefined,
+  chain extends Chain | undefined = Chain | undefined,
 > = {
   /**
    * The number of confirmations (blocks that have passed) to wait before resolving.
@@ -59,7 +59,7 @@ export type WaitForTransactionReceiptParameters<
   /** The hash of the transaction. */
   hash: Hash
   /** Optional callback to emit if the transaction has been replaced. */
-  onReplaced?: ((response: ReplacementReturnType<TChain>) => void) | undefined
+  onReplaced?: ((response: ReplacementReturnType<chain>) => void) | undefined
   /**
    * Polling frequency (in ms). Defaults to the client's pollingInterval config.
    * @default client.pollingInterval
@@ -126,9 +126,9 @@ export type WaitForTransactionReceiptErrorType =
  * })
  */
 export async function waitForTransactionReceipt<
-  TChain extends Chain | undefined,
+  chain extends Chain | undefined,
 >(
-  client: Client<Transport, TChain>,
+  client: Client<Transport, chain>,
   {
     confirmations = 1,
     hash,
@@ -137,14 +137,14 @@ export async function waitForTransactionReceipt<
     retryCount = 6,
     retryDelay = ({ count }) => ~~(1 << count) * 200, // exponential backoff
     timeout,
-  }: WaitForTransactionReceiptParameters<TChain>,
-): Promise<WaitForTransactionReceiptReturnType<TChain>> {
+  }: WaitForTransactionReceiptParameters<chain>,
+): Promise<WaitForTransactionReceiptReturnType<chain>> {
   const observerId = stringify(['waitForTransactionReceipt', client.uid, hash])
 
   let count = 0
-  let transaction: GetTransactionReturnType<TChain> | undefined
-  let replacedTransaction: GetTransactionReturnType<TChain> | undefined
-  let receipt: GetTransactionReceiptReturnType<TChain>
+  let transaction: GetTransactionReturnType<chain> | undefined
+  let replacedTransaction: GetTransactionReturnType<chain> | undefined
+  let receipt: GetTransactionReceiptReturnType<chain>
   let retrying = false
 
   return new Promise((resolve, reject) => {
@@ -210,7 +210,7 @@ export async function waitForTransactionReceipt<
                       client,
                       getTransaction,
                       'getTransaction',
-                    )({ hash })) as GetTransactionReturnType<TChain>
+                    )({ hash })) as GetTransactionReturnType<chain>
                     if (transaction.blockNumber)
                       blockNumber = transaction.blockNumber
                   },

package/actions/public/watchBlockNumber.ts

@@ -21,14 +21,14 @@ export type OnBlockNumberFn = (
 ) => void
 
 export type WatchBlockNumberParameters<
-  TTransport extends Transport = Transport,
+  transport extends Transport = Transport,
 > = {
   /** The callback to call when a new block number is received. */
   onBlockNumber: OnBlockNumberFn
   /** The callback to call when an error occurred when trying to get for a new block. */
   onError?: ((error: Error) => void) | undefined
 } & (
-  | (HasTransportType<TTransport, 'webSocket'> extends true
+  | (HasTransportType<transport, 'webSocket'> extends true
       ? {
           emitMissed?: undefined
           emitOnBegin?: undefined
@@ -78,10 +78,10 @@ export type WatchBlockNumberErrorType = PollErrorType | ErrorType
  * })
  */
 export function watchBlockNumber<
-  TChain extends Chain | undefined,
-  TTransport extends Transport,
+  chain extends Chain | undefined,
+  transport extends Transport,
 >(
-  client: Client<TTransport, TChain>,
+  client: Client<transport, chain>,
   {
     emitOnBegin = false,
     emitMissed = false,
@@ -89,7 +89,7 @@ export function watchBlockNumber<
     onError,
     poll: poll_,
     pollingInterval = client.pollingInterval,
-  }: WatchBlockNumberParameters<TTransport>,
+  }: WatchBlockNumberParameters<transport>,
 ): WatchBlockNumberReturnType {
   const enablePolling = (() => {
     if (typeof poll_ !== 'undefined') return poll_

package/actions/public/watchBlocks.ts

@@ -13,34 +13,32 @@ import { type StringifyErrorType, stringify } from '../../utils/stringify.js'
 import { type GetBlockReturnType, getBlock } from './getBlock.js'
 
 export type OnBlockParameter<
-  TChain extends Chain | undefined = Chain,
-  TIncludeTransactions extends boolean = false,
-  TBlockTag extends BlockTag = 'latest',
-> = GetBlockReturnType<TChain, TIncludeTransactions, TBlockTag>
+  chain extends Chain | undefined = Chain,
+  includeTransactions extends boolean = false,
+  blockTag extends BlockTag = 'latest',
+> = GetBlockReturnType<chain, includeTransactions, blockTag>
 
 export type OnBlock<
-  TChain extends Chain | undefined = Chain,
-  TIncludeTransactions extends boolean = false,
-  TBlockTag extends BlockTag = 'latest',
+  chain extends Chain | undefined = Chain,
+  includeTransactions extends boolean = false,
+  blockTag extends BlockTag = 'latest',
 > = (
-  block: OnBlockParameter<TChain, TIncludeTransactions, TBlockTag>,
-  prevBlock:
-    | OnBlockParameter<TChain, TIncludeTransactions, TBlockTag>
-    | undefined,
+  block: OnBlockParameter<chain, includeTransactions, blockTag>,
+  prevBlock: OnBlockParameter<chain, includeTransactions, blockTag> | undefined,
 ) => void
 
 export type WatchBlocksParameters<
-  TTransport extends Transport = Transport,
-  TChain extends Chain | undefined = Chain,
-  TIncludeTransactions extends boolean = false,
-  TBlockTag extends BlockTag = 'latest',
+  transport extends Transport = Transport,
+  chain extends Chain | undefined = Chain,
+  includeTransactions extends boolean = false,
+  blockTag extends BlockTag = 'latest',
 > = {
   /** The callback to call when a new block is received. */
-  onBlock: OnBlock<TChain, TIncludeTransactions, TBlockTag>
+  onBlock: OnBlock<chain, includeTransactions, blockTag>
   /** The callback to call when an error occurred when trying to get for a new block. */
   onError?: ((error: Error) => void) | undefined
 } & (
-  | (HasTransportType<TTransport, 'webSocket'> extends true
+  | (HasTransportType<transport, 'webSocket'> extends true
       ? {
           blockTag?: undefined
           emitMissed?: undefined
@@ -53,13 +51,13 @@ export type WatchBlocksParameters<
       : never)
   | {
       /** The block tag. Defaults to "latest". */
-      blockTag?: TBlockTag | BlockTag | undefined
+      blockTag?: blockTag | BlockTag | undefined
       /** Whether or not to emit the missed blocks to the callback. */
       emitMissed?: boolean | undefined
       /** Whether or not to emit the block to the callback when the subscription opens. */
       emitOnBegin?: boolean | undefined
       /** Whether or not to include transaction data in the response. */
-      includeTransactions?: TIncludeTransactions | undefined
+      includeTransactions?: includeTransactions | undefined
       poll?: true | undefined
       /** Polling frequency (in ms). Defaults to the client's pollingInterval config. */
       pollingInterval?: number | undefined
@@ -99,12 +97,12 @@ export type WatchBlocksErrorType =
  * })
  */
 export function watchBlocks<
-  TTransport extends Transport,
-  TChain extends Chain | undefined,
-  TIncludeTransactions extends boolean = false,
-  TBlockTag extends BlockTag = 'latest',
+  transport extends Transport,
+  chain extends Chain | undefined,
+  includeTransactions extends boolean = false,
+  blockTag extends BlockTag = 'latest',
 >(
-  client: Client<TTransport, TChain>,
+  client: Client<transport, chain>,
   {
     blockTag = 'latest',
     emitMissed = false,
@@ -114,7 +112,7 @@ export function watchBlocks<
     includeTransactions: includeTransactions_,
     poll: poll_,
     pollingInterval = client.pollingInterval,
-  }: WatchBlocksParameters<TTransport, TChain, TIncludeTransactions, TBlockTag>,
+  }: WatchBlocksParameters<transport, chain, includeTransactions, blockTag>,
 ): WatchBlocksReturnType {
   const enablePolling = (() => {
     if (typeof poll_ !== 'undefined') return poll_
@@ -129,7 +127,7 @@ export function watchBlocks<
   const includeTransactions = includeTransactions_ ?? false
 
   let prevBlock:
-    | GetBlockReturnType<TChain, false | TIncludeTransactions, 'latest'>
+    | GetBlockReturnType<chain, false | includeTransactions, 'latest'>
     | undefined
 
   const pollBlocks = () => {
@@ -171,7 +169,7 @@ export function watchBlocks<
                   )({
                     blockNumber: i,
                     includeTransactions,
-                  })) as GetBlockReturnType<TChain>
+                  })) as GetBlockReturnType<chain>
                   emit.onBlock(block as any, prevBlock as any)
                   prevBlock = block
                 }

package/actions/public/watchEvent.ts

@@ -39,35 +39,37 @@ import { type GetLogsParameters, getLogs } from './getLogs.js'
 import { uninstallFilter } from './uninstallFilter.js'
 
 export type WatchEventOnLogsParameter<
-  TAbiEvent extends AbiEvent | undefined = undefined,
-  TAbiEvents extends
+  abiEvent extends AbiEvent | undefined = undefined,
+  abiEvents extends
     | readonly AbiEvent[]
     | readonly unknown[]
-    | undefined = TAbiEvent extends AbiEvent ? [TAbiEvent] : undefined,
-  TStrict extends boolean | undefined = undefined,
-  TEventName extends string | undefined = MaybeAbiEventName<TAbiEvent>,
-> = Log<bigint, number, false, TAbiEvent, TStrict, TAbiEvents, TEventName>[]
+    | undefined = abiEvent extends AbiEvent ? [abiEvent] : undefined,
+  strict extends boolean | undefined = undefined,
+  eventName extends string | undefined = MaybeAbiEventName<abiEvent>,
+> = Log<bigint, number, false, abiEvent, strict, abiEvents, eventName>[]
 export type WatchEventOnLogsFn<
-  TAbiEvent extends AbiEvent | undefined = undefined,
-  TAbiEvents extends
+  abiEvent extends AbiEvent | undefined = undefined,
+  abiEvents extends
     | readonly AbiEvent[]
     | readonly unknown[]
-    | undefined = TAbiEvent extends AbiEvent ? [TAbiEvent] : undefined,
-  TStrict extends boolean | undefined = undefined,
-  _EventName extends string | undefined = MaybeAbiEventName<TAbiEvent>,
+    | undefined = abiEvent extends AbiEvent ? [abiEvent] : undefined,
+  strict extends boolean | undefined = undefined,
+  //
+  _eventName extends string | undefined = MaybeAbiEventName<abiEvent>,
 > = (
-  logs: WatchEventOnLogsParameter<TAbiEvent, TAbiEvents, TStrict, _EventName>,
+  logs: WatchEventOnLogsParameter<abiEvent, abiEvents, strict, _eventName>,
 ) => void
 
 export type WatchEventParameters<
-  TAbiEvent extends AbiEvent | undefined = undefined,
-  TAbiEvents extends
+  abiEvent extends AbiEvent | undefined = undefined,
+  abiEvents extends
     | readonly AbiEvent[]
     | readonly unknown[]
-    | undefined = TAbiEvent extends AbiEvent ? [TAbiEvent] : undefined,
-  TStrict extends boolean | undefined = undefined,
-  TTransport extends Transport = Transport,
-  _EventName extends string | undefined = MaybeAbiEventName<TAbiEvent>,
+    | undefined = abiEvent extends AbiEvent ? [abiEvent] : undefined,
+  strict extends boolean | undefined = undefined,
+  transport extends Transport = Transport,
+  //
+  _eventName extends string | undefined = MaybeAbiEventName<abiEvent>,
 > = {
   /** The address of the contract. */
   address?: Address | Address[] | undefined
@@ -76,28 +78,28 @@ export type WatchEventParameters<
   /** The callback to call when an error occurred when trying to get for a new block. */
   onError?: ((error: Error) => void) | undefined
   /** The callback to call when new event logs are received. */
-  onLogs: WatchEventOnLogsFn<TAbiEvent, TAbiEvents, TStrict, _EventName>
-} & GetPollOptions<TTransport> &
+  onLogs: WatchEventOnLogsFn<abiEvent, abiEvents, strict, _eventName>
+} & GetPollOptions<transport> &
   (
     | {
-        event: TAbiEvent
+        event: abiEvent
         events?: undefined
-        args?: MaybeExtractEventArgsFromAbi<TAbiEvents, _EventName> | undefined
+        args?: MaybeExtractEventArgsFromAbi<abiEvents, _eventName> | undefined
         /**
          * Whether or not the logs must match the indexed/non-indexed arguments on `event`.
          * @default false
          */
-        strict?: TStrict | undefined
+        strict?: strict | undefined
       }
     | {
         event?: undefined
-        events?: TAbiEvents | undefined
+        events?: abiEvents | undefined
         args?: undefined
         /**
          * Whether or not the logs must match the indexed/non-indexed arguments on `event`.
          * @default false
          */
-        strict?: TStrict | undefined
+        strict?: strict | undefined
       }
     | {
         event?: undefined
@@ -147,17 +149,17 @@ export type WatchEventErrorType =
  * })
  */
 export function watchEvent<
-  TChain extends Chain | undefined,
-  const TAbiEvent extends AbiEvent | undefined = undefined,
-  const TAbiEvents extends
+  chain extends Chain | undefined,
+  const abiEvent extends AbiEvent | undefined = undefined,
+  const abiEvents extends
     | readonly AbiEvent[]
     | readonly unknown[]
-    | undefined = TAbiEvent extends AbiEvent ? [TAbiEvent] : undefined,
-  TStrict extends boolean | undefined = undefined,
-  TTransport extends Transport = Transport,
-  _EventName extends string | undefined = undefined,
+    | undefined = abiEvent extends AbiEvent ? [abiEvent] : undefined,
+  strict extends boolean | undefined = undefined,
+  transport extends Transport = Transport,
+  _eventName extends string | undefined = undefined,
 >(
-  client: Client<TTransport, TChain>,
+  client: Client<transport, chain>,
   {
     address,
     args,
@@ -170,7 +172,7 @@ export function watchEvent<
     poll: poll_,
     pollingInterval = client.pollingInterval,
     strict: strict_,
-  }: WatchEventParameters<TAbiEvent, TAbiEvents, TStrict, TTransport>,
+  }: WatchEventParameters<abiEvent, abiEvents, strict, transport>,
 ): WatchEventReturnType {
   const enablePolling = (() => {
     if (typeof poll_ !== 'undefined') return poll_
@@ -200,7 +202,7 @@ export function watchEvent<
     return observe(observerId, { onLogs, onError }, (emit) => {
       let previousBlockNumber: bigint
       if (fromBlock !== undefined) previousBlockNumber = fromBlock - 1n
-      let filter: Filter<'event', TAbiEvents, _EventName, any>
+      let filter: Filter<'event', abiEvents, _eventName, any>
       let initialized = false
 
       const unwatch = poll(
@@ -220,8 +222,8 @@ export function watchEvent<
                 fromBlock,
               } as unknown as CreateEventFilterParameters)) as unknown as Filter<
                 'event',
-                TAbiEvents,
-                _EventName
+                abiEvents,
+                _eventName
               >
             } catch {}
             initialized = true

package/actions/public/watchPendingTransactions.ts

@@ -18,13 +18,13 @@ export type OnTransactionsParameter = Hash[]
 export type OnTransactionsFn = (transactions: OnTransactionsParameter) => void
 
 export type WatchPendingTransactionsParameters<
-  TTransport extends Transport = Transport,
+  transport extends Transport = Transport,
 > = {
   /** The callback to call when an error occurred when trying to get for a new block. */
   onError?: ((error: Error) => void) | undefined
   /** The callback to call when new transactions are received. */
   onTransactions: OnTransactionsFn
-} & GetPollOptions<TTransport>
+} & GetPollOptions<transport>
 
 export type WatchPendingTransactionsReturnType = () => void
 
@@ -63,17 +63,17 @@ export type WatchPendingTransactionsErrorType =
  * })
  */
 export function watchPendingTransactions<
-  TTransport extends Transport,
-  TChain extends Chain | undefined,
+  transport extends Transport,
+  chain extends Chain | undefined,
 >(
-  client: Client<TTransport, TChain>,
+  client: Client<transport, chain>,
   {
     batch = true,
     onError,
     onTransactions,
     poll: poll_,
     pollingInterval = client.pollingInterval,
-  }: WatchPendingTransactionsParameters<TTransport>,
+  }: WatchPendingTransactionsParameters<transport>,
 ) {
   const enablePolling =
     typeof poll_ !== 'undefined' ? poll_ : client.transport.type !== 'webSocket'

package/actions/test/dropTransaction.ts

@@ -39,10 +39,10 @@ export type DropTransactionErrorType = RequestErrorType | ErrorType
  * })
  */
 export async function dropTransaction<
-  TChain extends Chain | undefined,
-  TAccount extends Account | undefined,
+  chain extends Chain | undefined,
+  account extends Account | undefined,
 >(
-  client: TestClient<TestClientMode, Transport, TChain, TAccount, false>,
+  client: TestClient<TestClientMode, Transport, chain, account, false>,
   { hash }: DropTransactionParameters,
 ) {
   await client.request({

package/actions/test/dumpState.ts

@@ -33,10 +33,10 @@ export type DumpStateErrorType = RequestErrorType | ErrorType
  * await dumpState(client)
  */
 export async function dumpState<
-  TChain extends Chain | undefined,
-  TAccount extends Account | undefined,
+  chain extends Chain | undefined,
+  account extends Account | undefined,
 >(
-  client: TestClient<TestClientMode, Transport, TChain, TAccount, false>,
+  client: TestClient<TestClientMode, Transport, chain, account, false>,
 ): Promise<DumpStateReturnType> {
   return client.request({
     method: `${client.mode}_dumpState`,

package/actions/test/getAutomine.ts

@@ -33,10 +33,10 @@ export type GetAutomineErrorType = RequestErrorType | ErrorType
  * const isAutomining = await getAutomine(client)
  */
 export async function getAutomine<
-  TChain extends Chain | undefined,
-  TAccount extends Account | undefined,
+  chain extends Chain | undefined,
+  account extends Account | undefined,
 >(
-  client: TestClient<TestClientMode, Transport, TChain, TAccount, false>,
+  client: TestClient<TestClientMode, Transport, chain, account, false>,
 ): Promise<GetAutomineReturnType> {
   if (client.mode === 'ganache')
     return await client.request({

package/actions/test/getTxpoolContent.ts

@@ -41,10 +41,10 @@ export type GetTxpoolContentErrorType = RequestErrorType | ErrorType
  * const content = await getTxpoolContent(client)
  */
 export async function getTxpoolContent<
-  TChain extends Chain | undefined,
-  TAccount extends Account | undefined,
+  chain extends Chain | undefined,
+  account extends Account | undefined,
 >(
-  client: TestClient<TestClientMode, Transport, TChain, TAccount, false>,
+  client: TestClient<TestClientMode, Transport, chain, account, false>,
 ): Promise<GetTxpoolContentReturnType> {
   return await client.request({
     method: 'txpool_content',

package/actions/test/getTxpoolStatus.ts

@@ -37,10 +37,10 @@ export type GetTxpoolStatusErrorType = RequestErrorType | ErrorType
  * const status = await getTxpoolStatus(client)
  */
 export async function getTxpoolStatus<
-  TChain extends Chain | undefined,
-  TAccount extends Account | undefined,
+  chain extends Chain | undefined,
+  account extends Account | undefined,
 >(
-  client: TestClient<TestClientMode, Transport, TChain, TAccount, false>,
+  client: TestClient<TestClientMode, Transport, chain, account, false>,
 ): Promise<GetTxpoolStatusReturnType> {
   const { pending, queued } = await client.request({
     method: 'txpool_status',

package/actions/test/impersonateAccount.ts

@@ -40,10 +40,10 @@ export type ImpersonateAccountErrorType = RequestErrorType | ErrorType
  * })
  */
 export async function impersonateAccount<
-  TChain extends Chain | undefined,
-  TAccount extends Account | undefined,
+  chain extends Chain | undefined,
+  account extends Account | undefined,
 >(
-  client: TestClient<TestClientMode, Transport, TChain, TAccount, false>,
+  client: TestClient<TestClientMode, Transport, chain, account, false>,
   { address }: ImpersonateAccountParameters,
 ) {
   await client.request({

package/actions/test/increaseTime.ts

@@ -39,10 +39,10 @@ export type IncreaseTimeErrorType = RequestErrorType | ErrorType
  * })
  */
 export async function increaseTime<
-  TChain extends Chain | undefined,
-  TAccount extends Account | undefined,
+  chain extends Chain | undefined,
+  account extends Account | undefined,
 >(
-  client: TestClient<TestClientMode, Transport, TChain, TAccount, false>,
+  client: TestClient<TestClientMode, Transport, chain, account, false>,
   { seconds }: IncreaseTimeParameters,
 ) {
   return await client.request({

package/actions/test/inspectTxpool.ts

@@ -38,10 +38,10 @@ export type InspectTxpoolErrorType = RequestErrorType | ErrorType
  * const data = await inspectTxpool(client)
  */
 export async function inspectTxpool<
-  TChain extends Chain | undefined,
-  TAccount extends Account | undefined,
+  chain extends Chain | undefined,
+  account extends Account | undefined,
 >(
-  client: TestClient<TestClientMode, Transport, TChain, TAccount, false>,
+  client: TestClient<TestClientMode, Transport, chain, account, false>,
 ): Promise<InspectTxpoolReturnType> {
   return await client.request({
     method: 'txpool_inspect',

package/actions/test/loadState.ts

@@ -34,10 +34,10 @@ export type LoadStateErrorType = RequestErrorType | ErrorType
  * await loadState(client, { state: '0x...' })
  */
 export async function loadState<
-  TChain extends Chain | undefined,
-  TAccount extends Account | undefined,
+  chain extends Chain | undefined,
+  account extends Account | undefined,
 >(
-  client: TestClient<TestClientMode, Transport, TChain, TAccount, false>,
+  client: TestClient<TestClientMode, Transport, chain, account, false>,
   { state }: LoadStateParameters,
 ): Promise<LoadStateReturnType> {
   await client.request({

package/actions/test/mine.ts

@@ -39,10 +39,10 @@ export type MineErrorType = RequestErrorType | ErrorType
  * await mine(client, { blocks: 1 })
  */
 export async function mine<
-  TChain extends Chain | undefined,
-  TAccount extends Account | undefined,
+  chain extends Chain | undefined,
+  account extends Account | undefined,
 >(
-  client: TestClient<TestClientMode, Transport, TChain, TAccount, false>,
+  client: TestClient<TestClientMode, Transport, chain, account, false>,
   { blocks, interval }: MineParameters,
 ) {
   if (client.mode === 'ganache')

package/actions/test/removeBlockTimestampInterval.ts

@@ -30,9 +30,9 @@ export type RemoveBlockTimestampIntervalErrorType = RequestErrorType | ErrorType
  * await removeBlockTimestampInterval(client)
  */
 export async function removeBlockTimestampInterval<
-  TChain extends Chain | undefined,
-  TAccount extends Account | undefined,
->(client: TestClient<TestClientMode, Transport, TChain, TAccount, false>) {
+  chain extends Chain | undefined,
+  account extends Account | undefined,
+>(client: TestClient<TestClientMode, Transport, chain, account, false>) {
   await client.request({
     method: `${client.mode}_removeBlockTimestampInterval`,
   })

package/actions/test/reset.ts

@@ -38,10 +38,10 @@ export type ResetErrorType = RequestErrorType | ErrorType
  * await reset(client, { blockNumber: 69420n })
  */
 export async function reset<
-  TChain extends Chain | undefined,
-  TAccount extends Account | undefined,
+  chain extends Chain | undefined,
+  account extends Account | undefined,
 >(
-  client: TestClient<TestClientMode, Transport, TChain, TAccount, false>,
+  client: TestClient<TestClientMode, Transport, chain, account, false>,
   { blockNumber, jsonRpcUrl }: ResetParameters = {},
 ) {
   await client.request({