viem 0.0.0-portable-types-20230523145621 → 0.0.0-refactor-generics-20230831161903

package/src/actions/public/getLogs.ts

@@ -1,7 +1,11 @@
-import type { AbiEvent, Address, Narrow } from 'abitype'
+import type { Abi, AbiEvent, Address } from 'abitype'
 
-import type { PublicClient } from '../../clients/createPublicClient.js'
+import type { Client } from '../../clients/createClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
+import {
+  DecodeLogDataMismatch,
+  DecodeLogTopicsMismatch,
+} from '../../errors/abi.js'
 import type { BlockNumber, BlockTag } from '../../types/block.js'
 import type { Chain } from '../../types/chain.js'
 import type {
@@ -21,26 +25,51 @@ import { formatLog } from '../../utils/formatters/log.js'
 
 export type GetLogsParameters<
   TAbiEvent extends AbiEvent | undefined = undefined,
-  TEventName extends string | undefined = MaybeAbiEventName<TAbiEvent>,
+  TAbiEvents extends
+    | readonly AbiEvent[]
+    | readonly unknown[]
+    | undefined = TAbiEvent extends AbiEvent ? [TAbiEvent] : undefined,
+  TStrict extends boolean | undefined = undefined,
+  TFromBlock extends BlockNumber | BlockTag | undefined = undefined,
+  TToBlock extends BlockNumber | BlockTag | undefined = undefined,
+  _EventName extends string | undefined = MaybeAbiEventName<TAbiEvent>,
 > = {
   /** Address or list of addresses from which logs originated */
   address?: Address | Address[]
 } & (
   | {
-      event: Narrow<TAbiEvent>
-      args?: MaybeExtractEventArgsFromAbi<[TAbiEvent], TEventName>
+      event: TAbiEvent
+      events?: never
+      args?: MaybeExtractEventArgsFromAbi<TAbiEvents, _EventName>
+      /**
+       * Whether or not the logs must match the indexed/non-indexed arguments on `event`.
+       * @default false
+       */
+      strict?: TStrict
+    }
+  | {
+      event?: never
+      events: TAbiEvents
+      args?: never
+      /**
+       * Whether or not the logs must match the indexed/non-indexed arguments on `event`.
+       * @default false
+       */
+      strict?: TStrict
     }
   | {
       event?: never
+      events?: never
       args?: never
+      strict?: never
     }
 ) &
   (
     | {
         /** Block number or tag after which to include logs */
-        fromBlock?: BlockNumber<bigint> | BlockTag
+        fromBlock?: TFromBlock | BlockNumber | BlockTag
         /** Block number or tag before which to include logs */
-        toBlock?: BlockNumber<bigint> | BlockTag
+        toBlock?: TToBlock | BlockNumber | BlockTag
         blockHash?: never
       }
     | {
@@ -53,8 +82,18 @@ export type GetLogsParameters<
 
 export type GetLogsReturnType<
   TAbiEvent extends AbiEvent | undefined = undefined,
-  TEventName extends string | undefined = MaybeAbiEventName<TAbiEvent>,
-> = Log<bigint, number, TAbiEvent, [TAbiEvent], TEventName>[]
+  TAbiEvents extends
+    | readonly AbiEvent[]
+    | readonly unknown[]
+    | undefined = TAbiEvent extends AbiEvent ? [TAbiEvent] : undefined,
+  TStrict extends boolean | undefined = undefined,
+  TFromBlock extends BlockNumber | BlockTag | undefined = undefined,
+  TToBlock extends BlockNumber | BlockTag | undefined = undefined,
+  _EventName extends string | undefined = MaybeAbiEventName<TAbiEvent>,
+  _Pending extends boolean =
+    | (TFromBlock extends 'pending' ? true : false)
+    | (TToBlock extends 'pending' ? true : false),
+> = Log<bigint, number, _Pending, TAbiEvent, TStrict, TAbiEvents, _EventName>[]
 
 /**
  * Returns a list of event logs matching the provided parameters.
@@ -80,25 +119,51 @@ export type GetLogsReturnType<
  */
 export async function getLogs<
   TChain extends Chain | undefined,
-  TAbiEvent extends AbiEvent | undefined,
+  const TAbiEvent extends AbiEvent | undefined = undefined,
+  const TAbiEvents extends
+    | readonly AbiEvent[]
+    | readonly unknown[]
+    | undefined = TAbiEvent extends AbiEvent ? [TAbiEvent] : undefined,
+  TStrict extends boolean | undefined = undefined,
+  TFromBlock extends BlockNumber | BlockTag | undefined = undefined,
+  TToBlock extends BlockNumber | BlockTag | undefined = undefined,
 >(
-  client: PublicClient<Transport, TChain>,
+  client: Client<Transport, TChain>,
   {
     address,
     blockHash,
     fromBlock,
     toBlock,
     event,
+    events: events_,
     args,
-  }: GetLogsParameters<TAbiEvent> = {},
-): Promise<GetLogsReturnType<TAbiEvent>> {
+    strict: strict_,
+  }: GetLogsParameters<
+    TAbiEvent,
+    TAbiEvents,
+    TStrict,
+    TFromBlock,
+    TToBlock
+  > = {},
+): Promise<
+  GetLogsReturnType<TAbiEvent, TAbiEvents, TStrict, TFromBlock, TToBlock>
+> {
+  const strict = strict_ ?? false
+  const events = events_ ?? (event ? [event] : undefined)
+
   let topics: LogTopic[] = []
-  if (event)
-    topics = encodeEventTopics({
-      abi: [event],
-      eventName: (event as AbiEvent).name,
-      args,
-    } as EncodeEventTopicsParameters)
+  if (events) {
+    topics = [
+      (events as AbiEvent[]).flatMap((event) =>
+        encodeEventTopics({
+          abi: [event],
+          eventName: (event as AbiEvent).name,
+          args,
+        } as EncodeEventTopicsParameters),
+      ),
+    ]
+    if (event) topics = topics[0] as LogTopic[]
+  }
 
   let logs: RpcLog[]
   if (blockHash) {
@@ -124,18 +189,37 @@ export async function getLogs<
   return logs
     .map((log) => {
       try {
-        const { eventName, args } = event
+        const { eventName, args } = events
           ? decodeEventLog({
-              abi: [event] as [AbiEvent],
+              abi: events as Abi,
               data: log.data,
               topics: log.topics as any,
+              strict,
             })
           : { eventName: undefined, args: undefined }
-        return formatLog(log, { args, eventName })
-      } catch {
-        // Skip log if there is an error decoding (e.g. indexed/non-indexed params mismatch).
-        return
+        return formatLog(log, { args, eventName: eventName as string })
+      } catch (err) {
+        let eventName
+        let isUnnamed
+        if (
+          err instanceof DecodeLogDataMismatch ||
+          err instanceof DecodeLogTopicsMismatch
+        ) {
+          // If strict mode is on, and log data/topics do not match event definition, skip.
+          if (strict) return
+          eventName = err.abiItem.name
+          isUnnamed = err.abiItem.inputs?.some((x) => !('name' in x && x.name))
+        }
+
+        // Set args to empty if there is an error decoding (e.g. indexed/non-indexed params mismatch).
+        return formatLog(log, { args: isUnnamed ? [] : {}, eventName })
       }
     })
-    .filter(Boolean) as unknown as GetLogsReturnType<TAbiEvent>
+    .filter(Boolean) as unknown as GetLogsReturnType<
+    TAbiEvent,
+    TAbiEvents,
+    TStrict,
+    TFromBlock,
+    TToBlock
+  >
 }

package/src/actions/public/getStorageAt.ts

@@ -1,6 +1,6 @@
 import type { Address } from 'abitype'
 
-import type { PublicClient } from '../../clients/createPublicClient.js'
+import type { Client } from '../../clients/createClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
 import type { BlockTag } from '../../types/block.js'
 import type { Chain } from '../../types/chain.js'
@@ -48,7 +48,7 @@ export type GetStorageAtReturnType = Hex | undefined
  * })
  */
 export async function getStorageAt<TChain extends Chain | undefined>(
-  client: PublicClient<Transport, TChain>,
+  client: Client<Transport, TChain>,
   { address, blockNumber, blockTag = 'latest', slot }: GetStorageAtParameters,
 ): Promise<GetStorageAtReturnType> {
   const blockNumberHex =

package/src/actions/public/getTransaction.ts

@@ -1,4 +1,4 @@
-import type { PublicClient } from '../../clients/createPublicClient.js'
+import type { Client } from '../../clients/createClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
 import { TransactionNotFoundError } from '../../errors/transaction.js'
 import type { BlockTag } from '../../types/block.js'
@@ -6,14 +6,12 @@ import type { Chain } from '../../types/chain.js'
 import type { Hash } from '../../types/misc.js'
 import type { RpcTransaction } from '../../types/rpc.js'
 import { numberToHex } from '../../utils/encoding/toHex.js'
-import { format } from '../../utils/formatters/format.js'
 import {
   type FormattedTransaction,
-  type TransactionFormatter,
   formatTransaction,
 } from '../../utils/formatters/transaction.js'
 
-export type GetTransactionParameters =
+export type GetTransactionParameters<TBlockTag extends BlockTag = 'latest'> =
   | {
       /** The block hash */
       blockHash: Hash
@@ -36,7 +34,7 @@ export type GetTransactionParameters =
       blockHash?: never
       blockNumber?: never
       /** The block tag. */
-      blockTag: BlockTag
+      blockTag: TBlockTag | BlockTag
       hash?: never
       /** The index of the transaction on the block. */
       index: number
@@ -50,8 +48,10 @@ export type GetTransactionParameters =
       index?: number
     }
 
-export type GetTransactionReturnType<TChain extends Chain | undefined = Chain> =
-  FormattedTransaction<TransactionFormatter<TChain>>
+export type GetTransactionReturnType<
+  TChain extends Chain | undefined = Chain,
+  TBlockTag extends BlockTag = 'latest',
+> = FormattedTransaction<TChain, TBlockTag>
 
 /**
  * Returns information about a [Transaction](https://viem.sh/docs/glossary/terms.html#transaction) given a hash or block identifier.
@@ -77,16 +77,21 @@ export type GetTransactionReturnType<TChain extends Chain | undefined = Chain> =
  *   hash: '0x4ca7ee652d57678f26e887c149ab0735f41de37bcad58c9f6d3ed5824f15b74d',
  * })
  */
-export async function getTransaction<TChain extends Chain | undefined>(
-  client: PublicClient<Transport, TChain>,
+export async function getTransaction<
+  TChain extends Chain | undefined,
+  TBlockTag extends BlockTag = 'latest',
+>(
+  client: Client<Transport, TChain>,
   {
     blockHash,
     blockNumber,
-    blockTag = 'latest',
+    blockTag: blockTag_,
     hash,
     index,
-  }: GetTransactionParameters,
-): Promise<GetTransactionReturnType<TChain>> {
+  }: GetTransactionParameters<TBlockTag>,
+): Promise<GetTransactionReturnType<TChain, TBlockTag>> {
+  const blockTag = blockTag_ || 'latest'
+
   const blockNumberHex =
     blockNumber !== undefined ? numberToHex(blockNumber) : undefined
 
@@ -117,7 +122,7 @@ export async function getTransaction<TChain extends Chain | undefined>(
       index,
     })
 
-  return format(transaction, {
-    formatter: client.chain?.formatters?.transaction || formatTransaction,
-  })
+  const format =
+    client.chain?.formatters?.transaction?.format || formatTransaction
+  return format(transaction)
 }

package/src/actions/public/getTransactionConfirmations.ts

@@ -1,11 +1,8 @@
-import type { PublicClient } from '../../clients/createPublicClient.js'
+import type { Client } from '../../clients/createClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
 import type { Chain } from '../../types/chain.js'
 import type { Hash } from '../../types/misc.js'
-import type {
-  FormattedTransactionReceipt,
-  TransactionReceiptFormatter,
-} from '../../utils/formatters/transactionReceipt.js'
+import type { FormattedTransactionReceipt } from '../../utils/formatters/transactionReceipt.js'
 
 import { getBlockNumber } from './getBlockNumber.js'
 import { getTransaction } from './getTransaction.js'
@@ -21,9 +18,7 @@ export type GetTransactionConfirmationsParameters<
   | {
       hash?: never
       /** The transaction receipt. */
-      transactionReceipt: FormattedTransactionReceipt<
-        TransactionReceiptFormatter<TChain>
-      >
+      transactionReceipt: FormattedTransactionReceipt<TChain>
     }
 
 export type GetTransactionConfirmationsReturnType = bigint
@@ -55,7 +50,7 @@ export type GetTransactionConfirmationsReturnType = bigint
 export async function getTransactionConfirmations<
   TChain extends Chain | undefined,
 >(
-  client: PublicClient<Transport, TChain>,
+  client: Client<Transport, TChain>,
   { hash, transactionReceipt }: GetTransactionConfirmationsParameters<TChain>,
 ): Promise<GetTransactionConfirmationsReturnType> {
   const [blockNumber, transaction] = await Promise.all([

package/src/actions/public/getTransactionCount.ts

@@ -1,8 +1,7 @@
 import type { Address } from 'abitype'
 
 import type { Account } from '../../accounts/types.js'
-import type { PublicClient } from '../../clients/createPublicClient.js'
-import type { WalletClient } from '../../clients/createWalletClient.js'
+import type { Client } from '../../clients/createClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
 import type { BlockTag } from '../../types/block.js'
 import type { Chain } from '../../types/chain.js'
@@ -53,9 +52,7 @@ export async function getTransactionCount<
   TChain extends Chain | undefined,
   TAccount extends Account | undefined,
 >(
-  client:
-    | PublicClient<Transport, TChain>
-    | WalletClient<Transport, TChain, TAccount>,
+  client: Client<Transport, TChain, TAccount>,
   { address, blockTag = 'latest', blockNumber }: GetTransactionCountParameters,
 ): Promise<GetTransactionCountReturnType> {
   const count = await client.request({

package/src/actions/public/getTransactionReceipt.ts

@@ -1,12 +1,10 @@
-import type { PublicClient } from '../../clients/createPublicClient.js'
+import type { Client } from '../../clients/createClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
 import { TransactionReceiptNotFoundError } from '../../errors/transaction.js'
 import type { Chain } from '../../types/chain.js'
 import type { Hash } from '../../types/misc.js'
-import { format } from '../../utils/formatters/format.js'
 import {
   type FormattedTransactionReceipt,
-  type TransactionReceiptFormatter,
   formatTransactionReceipt,
 } from '../../utils/formatters/transactionReceipt.js'
 
@@ -17,7 +15,7 @@ export type GetTransactionReceiptParameters = {
 
 export type GetTransactionReceiptReturnType<
   TChain extends Chain | undefined = Chain | undefined,
-> = FormattedTransactionReceipt<TransactionReceiptFormatter<TChain>>
+> = FormattedTransactionReceipt<TChain>
 
 /**
  * Returns the [Transaction Receipt](https://viem.sh/docs/glossary/terms.html#transaction-receipt) given a [Transaction](https://viem.sh/docs/glossary/terms.html#transaction) hash.
@@ -44,7 +42,7 @@ export type GetTransactionReceiptReturnType<
  * })
  */
 export async function getTransactionReceipt<TChain extends Chain | undefined>(
-  client: PublicClient<Transport, TChain>,
+  client: Client<Transport, TChain>,
   { hash }: GetTransactionReceiptParameters,
 ) {
   const receipt = await client.request({
@@ -54,8 +52,8 @@ export async function getTransactionReceipt<TChain extends Chain | undefined>(
 
   if (!receipt) throw new TransactionReceiptNotFoundError({ hash })
 
-  return format(receipt, {
-    formatter:
-      client.chain?.formatters?.transactionReceipt || formatTransactionReceipt,
-  }) as GetTransactionReceiptReturnType<TChain>
+  const format =
+    client.chain?.formatters?.transactionReceipt?.format ||
+    formatTransactionReceipt
+  return format(receipt) as GetTransactionReceiptReturnType<TChain>
 }

package/src/actions/public/multicall.ts

@@ -1,10 +1,10 @@
 import type { Address, Narrow } from 'abitype'
 
-import type { PublicClient } from '../../clients/createPublicClient.js'
+import type { Client } from '../../clients/createClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
 import { multicall3Abi } from '../../constants/abis.js'
 import { AbiDecodingZeroDataError } from '../../errors/abi.js'
-import type { BaseError } from '../../errors/base.js'
+import { BaseError } from '../../errors/base.js'
 import { RawContractError } from '../../errors/contract.js'
 import type { Chain } from '../../types/chain.js'
 import type { ContractFunctionConfig } from '../../types/contract.js'
@@ -80,11 +80,11 @@ export type MulticallReturnType<
  * // [{ result: 424122n, status: 'success' }, { result: 1000000n, status: 'success' }]
  */
 export async function multicall<
-  TChain extends Chain | undefined,
   TContracts extends ContractFunctionConfig[],
+  TChain extends Chain | undefined,
   TAllowFailure extends boolean = true,
 >(
-  client: PublicClient<Transport, TChain>,
+  client: Client<Transport, TChain>,
   args: MulticallParameters<TContracts, TAllowFailure>,
 ): Promise<MulticallReturnType<TContracts, TAllowFailure>> {
   const {
@@ -92,7 +92,7 @@ export async function multicall<
     batchSize: batchSize_,
     blockNumber,
     blockTag,
-    contracts: contracts_,
+    contracts,
     multicallAddress: multicallAddress_,
   } = args
 
@@ -102,9 +102,6 @@ export async function multicall<
       client.batch.multicall.batchSize) ||
       1_024)
 
-  // Fix type cast from `Narrow` in type definition.
-  const contracts = contracts_ as readonly [...MulticallContracts<TContracts>]
-
   let multicallAddress = multicallAddress_
   if (!multicallAddress) {
     if (!client.chain)
@@ -129,7 +126,9 @@ export async function multicall<
   let currentChunk = 0
   let currentChunkSize = 0
   for (let i = 0; i < contracts.length; i++) {
-    const { abi, address, args, functionName } = contracts[i]
+    const { abi, address, args, functionName } = contracts[
+      i
+    ] as ContractFunctionConfig
     try {
       const callData = encodeFunctionData({
         abi,
@@ -137,8 +136,16 @@ export async function multicall<
         functionName,
       } as unknown as EncodeFunctionDataParameters)
 
-      currentChunkSize += callData.length
-      if (batchSize > 0 && currentChunkSize > batchSize) {
+      currentChunkSize += (callData.length - 2) / 2
+      // Check to see if we need to create a new chunk.
+      if (
+        // Check if batching is enabled.
+        batchSize > 0 &&
+        // Check if the current size of the batch exceeds the size limit.
+        currentChunkSize > batchSize &&
+        // Check if the current chunk is not already empty.
+        chunkedCalls[currentChunk].length > 0
+      ) {
         currentChunk++
         currentChunkSize = (callData.length - 2) / 2
         chunkedCalls[currentChunk] = []
@@ -172,7 +179,7 @@ export async function multicall<
     }
   }
 
-  const results = await Promise.all(
+  const aggregate3Results = await Promise.allSettled(
     chunkedCalls.map((calls) =>
       readContract(client, {
         abi: multicall3Abi,
@@ -185,29 +192,64 @@ export async function multicall<
     ),
   )
 
-  return results.flat().map(({ returnData, success }, i) => {
-    const calls = chunkedCalls.flat()
-    const { callData } = calls[i]
-    const { abi, address, functionName, args } = contracts[i]
-    try {
-      if (callData === '0x') throw new AbiDecodingZeroDataError()
-      if (!success) throw new RawContractError({ data: returnData })
-      const result = decodeFunctionResult({
-        abi,
-        data: returnData,
-        functionName: functionName,
-      })
-      return allowFailure ? { result, status: 'success' } : result
-    } catch (err) {
-      const error = getContractError(err as BaseError, {
-        abi,
-        address,
-        args,
-        docsPath: '/docs/contract/multicall',
-        functionName,
-      })
-      if (!allowFailure) throw error
-      return { error, result: undefined, status: 'failure' }
+  const results = []
+  for (let i = 0; i < aggregate3Results.length; i++) {
+    const result = aggregate3Results[i]
+
+    // If an error occurred in a `readContract` invocation (ie. network error),
+    // then append the failure reason to each contract result.
+    if (result.status === 'rejected') {
+      if (!allowFailure) throw result.reason
+      for (let j = 0; j < chunkedCalls[i].length; j++) {
+        results.push({
+          status: 'failure',
+          error: result.reason,
+          result: undefined,
+        })
+      }
+      continue
+    }
+
+    // If the `readContract` call was successful, then decode the results.
+    const aggregate3Result = result.value
+    for (let j = 0; j < aggregate3Result.length; j++) {
+      // Extract the response from `readContract`
+      const { returnData, success } = aggregate3Result[j]
+
+      // Extract the request call data from the original call.
+      const { callData } = chunkedCalls[i][j]
+
+      // Extract the contract config for this call from the `contracts` argument
+      // for decoding.
+      const { abi, address, functionName, args } = contracts[
+        results.length
+      ] as ContractFunctionConfig
+
+      try {
+        if (callData === '0x') throw new AbiDecodingZeroDataError()
+        if (!success) throw new RawContractError({ data: returnData })
+        const result = decodeFunctionResult({
+          abi,
+          args,
+          data: returnData,
+          functionName,
+        })
+        results.push(allowFailure ? { result, status: 'success' } : result)
+      } catch (err) {
+        const error = getContractError(err as BaseError, {
+          abi,
+          address,
+          args,
+          docsPath: '/docs/contract/multicall',
+          functionName,
+        })
+        if (!allowFailure) throw error
+        results.push({ error, result: undefined, status: 'failure' })
+      }
     }
-  }) as MulticallResults<TContracts, TAllowFailure>
+  }
+
+  if (results.length !== contracts.length)
+    throw new BaseError('multicall results mismatch')
+  return results as MulticallResults<TContracts, TAllowFailure>
 }

package/src/actions/public/readContract.ts

@@ -1,12 +1,14 @@
 import type { Abi } from 'abitype'
 
-import type { PublicClient } from '../../clients/createPublicClient.js'
+import type { Client } from '../../clients/createClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
 import type { BaseError } from '../../errors/base.js'
 import type { Chain } from '../../types/chain.js'
 import type {
-  ContractFunctionConfig,
-  ContractFunctionResult,
+  ContractFunctionArgs,
+  ContractFunctionName,
+  ContractFunctionParameters,
+  ContractFunctionReturnType,
 } from '../../types/contract.js'
 import {
   type DecodeFunctionResultParameters,
@@ -22,14 +24,30 @@ import { type CallParameters, call } from './call.js'
 
 export type ReadContractParameters<
   TAbi extends Abi | readonly unknown[] = Abi,
-  TFunctionName extends string = string,
+  TFunctionName extends ContractFunctionName<
+    TAbi,
+    'pure' | 'view'
+  > = ContractFunctionName<TAbi, 'pure' | 'view'>,
+  TArgs extends ContractFunctionArgs<
+    TAbi,
+    'pure' | 'view',
+    TFunctionName
+  > = ContractFunctionArgs<TAbi, 'pure' | 'view', TFunctionName>,
 > = Pick<CallParameters, 'account' | 'blockNumber' | 'blockTag'> &
-  ContractFunctionConfig<TAbi, TFunctionName, 'view' | 'pure'>
+  ContractFunctionParameters<TAbi, 'pure' | 'view', TFunctionName, TArgs>
 
 export type ReadContractReturnType<
   TAbi extends Abi | readonly unknown[] = Abi,
-  TFunctionName extends string = string,
-> = ContractFunctionResult<TAbi, TFunctionName>
+  TFunctionName extends ContractFunctionName<
+    TAbi,
+    'pure' | 'view'
+  > = ContractFunctionName<TAbi, 'pure' | 'view'>,
+  TArgs extends ContractFunctionArgs<
+    TAbi,
+    'pure' | 'view',
+    TFunctionName
+  > = ContractFunctionArgs<TAbi, 'pure' | 'view', TFunctionName>,
+> = ContractFunctionReturnType<TAbi, 'pure' | 'view', TFunctionName, TArgs>
 
 /**
  * Calls a read-only function on a contract, and returns the response.
@@ -64,18 +82,19 @@ export type ReadContractReturnType<
  */
 export async function readContract<
   TChain extends Chain | undefined,
-  TAbi extends Abi | readonly unknown[],
-  TFunctionName extends string,
+  const TAbi extends Abi | readonly unknown[],
+  TFunctionName extends ContractFunctionName<TAbi, 'pure' | 'view'>,
+  TArgs extends ContractFunctionArgs<TAbi, 'pure' | 'view', TFunctionName>,
 >(
-  client: PublicClient<Transport, TChain>,
+  client: Client<Transport, TChain>,
   {
     abi,
     address,
     args,
     functionName,
     ...callRequest
-  }: ReadContractParameters<TAbi, TFunctionName>,
-): Promise<ReadContractReturnType<TAbi, TFunctionName>> {
+  }: ReadContractParameters<TAbi, TFunctionName, TArgs>,
+): Promise<ReadContractReturnType<TAbi, TFunctionName, TArgs>> {
   const calldata = encodeFunctionData({
     abi,
     args,