viem 0.0.0-w-20230818210302 → 0.0.0-w-20230820223631

package/src/actions/getContract.ts

@@ -17,6 +17,7 @@ import type { Transport } from '../clients/transports/createTransport.js'
 import type { Chain } from '../types/chain.js'
 import type {
   AbiEventParametersToPrimitiveTypes,
+  ContractFunctionName,
   MaybeExtractEventArgsFromAbi,
 } from '../types/contract.js'
 import type {
@@ -119,81 +120,17 @@ export type GetContractReturnType<
     : string,
   _Narrowable extends boolean = IsNarrowable<TAbi, Abi>,
 > = Prettify<
-  (TPublicClient extends PublicClient
-    ? (IsNever<_ReadFunctionNames> extends true
-        ? unknown
-        : {
-            /**
-             * Calls a read-only function on a contract, and returns the response.
-             *
-             * A "read-only" function (constant function) on a Solidity contract is denoted by a `view` or `pure` keyword. They can only read the state of the contract, and cannot make any changes to it. Since read-only methods do not change the state of the contract, they do not require any gas to be executed, and can be called by any user without the need to pay for gas.
-             *
-             * Internally, `read` uses a [Public Client](https://viem.sh/docs/clients/public.html) to call the [`call` action](https://viem.sh/docs/actions/public/call.html) with [ABI-encoded `data`](https://viem.sh/docs/contract/encodeFunctionData.html).
-             *
-             * @example
-             * import { createPublicClient, getContract, http, parseAbi } from 'viem'
-             * import { mainnet } from 'viem/chains'
-             *
-             * const publicClient = createPublicClient({
-             *   chain: mainnet,
-             *   transport: http(),
-             * })
-             * const contract = getContract({
-             *   address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',
-             *   abi: parseAbi([
-             *     'function balanceOf(address owner) view returns (uint256)',
-             *   ]),
-             *   publicClient,
-             * })
-             * const result = await contract.read.balanceOf(['0xA0Cf798816D4b9b9866b5330EEa46a18382f251e'])
-             * // 424122n
-             */
-            read: {
-              [FunctionName in _ReadFunctionNames]: GetReadFunction<
-                _Narrowable,
-                TAbi,
-                FunctionName
-              >
-            }
-          }) &
-        (IsNever<_WriteFunctionNames> extends true
+  Prettify<
+    (TPublicClient extends PublicClient
+      ? (IsNever<_ReadFunctionNames> extends true
           ? unknown
           : {
               /**
-               * Estimates the gas necessary to complete a transaction without submitting it to the network.
-               *
-               * @example
-               * import { createPublicClient, getContract, http, parseAbi } from 'viem'
-               * import { mainnet } from 'viem/chains'
+               * Calls a read-only function on a contract, and returns the response.
                *
-               * const publicClient = createPublicClient({
-               *   chain: mainnet,
-               *   transport: http(),
-               * })
-               * const contract = getContract({
-               *   address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',
-               *   abi: parseAbi(['function mint() public']),
-               *   publicClient,
-               * })
-               * const gas = await contract.estimateGas.mint({
-               *   account: '0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266',
-               * })
-               */
-              estimateGas: {
-                [FunctionName in _WriteFunctionNames]: GetEstimateFunction<
-                  _Narrowable,
-                  TPublicClient['chain'],
-                  undefined,
-                  TAbi,
-                  FunctionName
-                >
-              }
-              /**
-               * Simulates/validates a contract interaction. This is useful for retrieving return data and revert reasons of contract write functions.
+               * A "read-only" function (constant function) on a Solidity contract is denoted by a `view` or `pure` keyword. They can only read the state of the contract, and cannot make any changes to it. Since read-only methods do not change the state of the contract, they do not require any gas to be executed, and can be called by any user without the need to pay for gas.
                *
-               * This function does not require gas to execute and does not change the state of the blockchain. It is almost identical to [`readContract`](https://viem.sh/docs/contract/readContract.html), but also supports contract write functions.
-               *
-               * Internally, `simulate` uses a [Public Client](https://viem.sh/docs/clients/public.html) to call the [`call` action](https://viem.sh/docs/actions/public/call.html) with [ABI-encoded `data`](https://viem.sh/docs/contract/encodeFunctionData.html).
+               * Internally, `read` uses a [Public Client](https://viem.sh/docs/clients/public.html) to call the [`call` action](https://viem.sh/docs/actions/public/call.html) with [ABI-encoded `data`](https://viem.sh/docs/contract/encodeFunctionData.html).
                *
                * @example
                * import { createPublicClient, getContract, http, parseAbi } from 'viem'
@@ -205,156 +142,227 @@ export type GetContractReturnType<
                * })
                * const contract = getContract({
                *   address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',
-               *   abi: parseAbi(['function mint() public']),
+               *   abi: parseAbi([
+               *     'function balanceOf(address owner) view returns (uint256)',
+               *   ]),
                *   publicClient,
                * })
-               * const result = await contract.simulate.mint({
-               *   account: '0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266',
-               * })
+               * const result = await contract.read.balanceOf(['0xA0Cf798816D4b9b9866b5330EEa46a18382f251e'])
+               * // 424122n
                */
-              simulate: {
-                [FunctionName in _WriteFunctionNames]: GetSimulateFunction<
+              read: {
+                [functionName in _ReadFunctionNames]: GetReadFunction<
                   _Narrowable,
-                  TPublicClient['chain'],
                   TAbi,
-                  FunctionName
+                  functionName extends ContractFunctionName<
+                    TAbi,
+                    'pure' | 'view'
+                  >
+                    ? functionName
+                    : never
                 >
               }
             }) &
-        (IsNever<_EventNames> extends true
+          (IsNever<_WriteFunctionNames> extends true
+            ? unknown
+            : {
+                /**
+                 * Estimates the gas necessary to complete a transaction without submitting it to the network.
+                 *
+                 * @example
+                 * import { createPublicClient, getContract, http, parseAbi } from 'viem'
+                 * import { mainnet } from 'viem/chains'
+                 *
+                 * const publicClient = createPublicClient({
+                 *   chain: mainnet,
+                 *   transport: http(),
+                 * })
+                 * const contract = getContract({
+                 *   address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',
+                 *   abi: parseAbi(['function mint() public']),
+                 *   publicClient,
+                 * })
+                 * const gas = await contract.estimateGas.mint({
+                 *   account: '0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266',
+                 * })
+                 */
+                estimateGas: {
+                  [functionName in _WriteFunctionNames]: GetEstimateFunction<
+                    _Narrowable,
+                    TPublicClient['chain'],
+                    undefined,
+                    TAbi,
+                    functionName
+                  >
+                }
+                /**
+                 * Simulates/validates a contract interaction. This is useful for retrieving return data and revert reasons of contract write functions.
+                 *
+                 * This function does not require gas to execute and does not change the state of the blockchain. It is almost identical to [`readContract`](https://viem.sh/docs/contract/readContract.html), but also supports contract write functions.
+                 *
+                 * Internally, `simulate` uses a [Public Client](https://viem.sh/docs/clients/public.html) to call the [`call` action](https://viem.sh/docs/actions/public/call.html) with [ABI-encoded `data`](https://viem.sh/docs/contract/encodeFunctionData.html).
+                 *
+                 * @example
+                 * import { createPublicClient, getContract, http, parseAbi } from 'viem'
+                 * import { mainnet } from 'viem/chains'
+                 *
+                 * const publicClient = createPublicClient({
+                 *   chain: mainnet,
+                 *   transport: http(),
+                 * })
+                 * const contract = getContract({
+                 *   address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',
+                 *   abi: parseAbi(['function mint() public']),
+                 *   publicClient,
+                 * })
+                 * const result = await contract.simulate.mint({
+                 *   account: '0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266',
+                 * })
+                 */
+                simulate: {
+                  [functionName in _WriteFunctionNames]: GetSimulateFunction<
+                    _Narrowable,
+                    TPublicClient['chain'],
+                    TAbi,
+                    functionName
+                  >
+                }
+              }) &
+          (IsNever<_EventNames> extends true
+            ? unknown
+            : {
+                /**
+                 * Creates a Filter to retrieve event logs that can be used with [`getFilterChanges`](https://viem.sh/docs/actions/public/getFilterChanges.html) or [`getFilterLogs`](https://viem.sh/docs/actions/public/getFilterLogs.html).
+                 *
+                 * @example
+                 * import { createPublicClient, getContract, http, parseAbi } from 'viem'
+                 * import { mainnet } from 'viem/chains'
+                 *
+                 * const publicClient = createPublicClient({
+                 *   chain: mainnet,
+                 *   transport: http(),
+                 * })
+                 * const contract = getContract({
+                 *   address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',
+                 *   abi: parseAbi(['event Transfer(address indexed, address indexed, uint256)']),
+                 *   publicClient,
+                 * })
+                 * const filter = await contract.createEventFilter.Transfer()
+                 */
+                createEventFilter: {
+                  [EventName in _EventNames]: GetEventFilter<
+                    _Narrowable,
+                    TAbi,
+                    EventName
+                  >
+                }
+                /**
+                 * Watches and returns emitted contract event logs.
+                 *
+                 * This Action will batch up all the event logs found within the [`pollingInterval`](https://viem.sh/docs/contract/watchContractEvent.html#pollinginterval-optional), and invoke them via [`onLogs`](https://viem.sh/docs/contract/watchContractEvent.html#onLogs).
+                 *
+                 * `watchEvent` will attempt to create an [Event Filter](https://viem.sh/docs/contract/createContractEventFilter.html) and listen to changes to the Filter per polling interval, however, if the RPC Provider does not support Filters (e.g. `eth_newFilter`), then `watchEvent` will fall back to using [`getLogs`](https://viem.sh/docs/actions/public/getLogs.html) instead.
+                 *
+                 * @example
+                 * import { createPublicClient, getContract, http, parseAbi } from 'viem'
+                 * import { mainnet } from 'viem/chains'
+                 *
+                 * const publicClient = createPublicClient({
+                 *   chain: mainnet,
+                 *   transport: http(),
+                 * })
+                 * const contract = getContract({
+                 *   address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',
+                 *   abi: parseAbi(['event Transfer(address indexed, address indexed, uint256)']),
+                 *   publicClient,
+                 * })
+                 * const filter = await contract.createEventFilter.Transfer()
+                 * const unwatch = contract.watchEvent.Transfer(
+                 *   { from: '0xc961145a54C96E3aE9bAA048c4F4D6b04C13916b' },
+                 *   { onLogs: (logs) => console.log(logs) },
+                 * )
+                 */
+                watchEvent: {
+                  [EventName in _EventNames]: GetWatchEvent<
+                    _Narrowable,
+                    TAbi,
+                    EventName
+                  >
+                }
+              })
+      : unknown) &
+      (TWalletClient extends WalletClient
+        ? IsNever<_WriteFunctionNames> extends true
           ? unknown
           : {
               /**
-               * Creates a Filter to retrieve event logs that can be used with [`getFilterChanges`](https://viem.sh/docs/actions/public/getFilterChanges.html) or [`getFilterLogs`](https://viem.sh/docs/actions/public/getFilterLogs.html).
+               * Estimates the gas necessary to complete a transaction without submitting it to the network.
                *
                * @example
-               * import { createPublicClient, getContract, http, parseAbi } from 'viem'
+               * import { createWalletClient, getContract, http, parseAbi } from 'viem'
                * import { mainnet } from 'viem/chains'
                *
-               * const publicClient = createPublicClient({
+               * const walletClient = createWalletClient({
                *   chain: mainnet,
                *   transport: http(),
                * })
                * const contract = getContract({
                *   address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',
-               *   abi: parseAbi(['event Transfer(address indexed, address indexed, uint256)']),
-               *   publicClient,
+               *   abi: parseAbi(['function mint() public']),
+               *   walletClient,
+               * })
+               * const gas = await contract.estimateGas.mint({
+               *   account: '0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266',
                * })
-               * const filter = await contract.createEventFilter.Transfer()
                */
-              createEventFilter: {
-                [EventName in _EventNames]: GetEventFilter<
+              estimateGas: {
+                [functionName in _WriteFunctionNames]: GetEstimateFunction<
                   _Narrowable,
+                  TWalletClient['chain'],
+                  TWalletClient['account'],
                   TAbi,
-                  EventName
+                  functionName
                 >
               }
               /**
-               * Watches and returns emitted contract event logs.
+               * Executes a write function on a contract.
                *
-               * This Action will batch up all the event logs found within the [`pollingInterval`](https://viem.sh/docs/contract/watchContractEvent.html#pollinginterval-optional), and invoke them via [`onLogs`](https://viem.sh/docs/contract/watchContractEvent.html#onLogs).
+               * A "write" function on a Solidity contract modifies the state of the blockchain. These types of functions require gas to be executed, and hence a [Transaction](https://viem.sh/docs/glossary/terms.html) is needed to be broadcast in order to change the state.
                *
-               * `watchEvent` will attempt to create an [Event Filter](https://viem.sh/docs/contract/createContractEventFilter.html) and listen to changes to the Filter per polling interval, however, if the RPC Provider does not support Filters (e.g. `eth_newFilter`), then `watchEvent` will fall back to using [`getLogs`](https://viem.sh/docs/actions/public/getLogs.html) instead.
+               * Internally, `write` uses a [Wallet Client](https://viem.sh/docs/clients/wallet.html) to call the [`sendTransaction` action](https://viem.sh/docs/actions/wallet/sendTransaction.html) with [ABI-encoded `data`](https://viem.sh/docs/contract/encodeFunctionData.html).
+               *
+               * __Warning: The `write` internally sends a transaction – it does not validate if the contract write will succeed (the contract may throw an error). It is highly recommended to [simulate the contract write with `contract.simulate`](https://viem.sh/docs/contract/writeContract.html#usage) before you execute it.__
                *
                * @example
-               * import { createPublicClient, getContract, http, parseAbi } from 'viem'
+               * import { createWalletClient, getContract, http, parseAbi } from 'viem'
                * import { mainnet } from 'viem/chains'
                *
-               * const publicClient = createPublicClient({
+               * const walletClient = createWalletClient({
                *   chain: mainnet,
                *   transport: http(),
                * })
                * const contract = getContract({
                *   address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',
-               *   abi: parseAbi(['event Transfer(address indexed, address indexed, uint256)']),
-               *   publicClient,
+               *   abi: parseAbi(['function mint(uint32 tokenId) nonpayable']),
+               *   walletClient,
+               * })
+               * const hash = await contract.write.min([69420], {
+               *   address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',
                * })
-               * const filter = await contract.createEventFilter.Transfer()
-               * const unwatch = contract.watchEvent.Transfer(
-               *   { from: '0xc961145a54C96E3aE9bAA048c4F4D6b04C13916b' },
-               *   { onLogs: (logs) => console.log(logs) },
-               * )
                */
-              watchEvent: {
-                [EventName in _EventNames]: GetWatchEvent<
+              write: {
+                [functionName in _WriteFunctionNames]: GetWriteFunction<
                   _Narrowable,
+                  TWalletClient['chain'],
+                  TWalletClient['account'],
                   TAbi,
-                  EventName
+                  functionName
                 >
               }
-            })
-    : unknown) &
-    (TWalletClient extends WalletClient
-      ? IsNever<_WriteFunctionNames> extends true
-        ? unknown
-        : {
-            /**
-             * Estimates the gas necessary to complete a transaction without submitting it to the network.
-             *
-             * @example
-             * import { createWalletClient, getContract, http, parseAbi } from 'viem'
-             * import { mainnet } from 'viem/chains'
-             *
-             * const walletClient = createWalletClient({
-             *   chain: mainnet,
-             *   transport: http(),
-             * })
-             * const contract = getContract({
-             *   address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',
-             *   abi: parseAbi(['function mint() public']),
-             *   walletClient,
-             * })
-             * const gas = await contract.estimateGas.mint({
-             *   account: '0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266',
-             * })
-             */
-            estimateGas: {
-              [FunctionName in _WriteFunctionNames]: GetEstimateFunction<
-                _Narrowable,
-                TWalletClient['chain'],
-                TWalletClient['account'],
-                TAbi,
-                FunctionName
-              >
-            }
-            /**
-             * Executes a write function on a contract.
-             *
-             * A "write" function on a Solidity contract modifies the state of the blockchain. These types of functions require gas to be executed, and hence a [Transaction](https://viem.sh/docs/glossary/terms.html) is needed to be broadcast in order to change the state.
-             *
-             * Internally, `write` uses a [Wallet Client](https://viem.sh/docs/clients/wallet.html) to call the [`sendTransaction` action](https://viem.sh/docs/actions/wallet/sendTransaction.html) with [ABI-encoded `data`](https://viem.sh/docs/contract/encodeFunctionData.html).
-             *
-             * __Warning: The `write` internally sends a transaction – it does not validate if the contract write will succeed (the contract may throw an error). It is highly recommended to [simulate the contract write with `contract.simulate`](https://viem.sh/docs/contract/writeContract.html#usage) before you execute it.__
-             *
-             * @example
-             * import { createWalletClient, getContract, http, parseAbi } from 'viem'
-             * import { mainnet } from 'viem/chains'
-             *
-             * const walletClient = createWalletClient({
-             *   chain: mainnet,
-             *   transport: http(),
-             * })
-             * const contract = getContract({
-             *   address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',
-             *   abi: parseAbi(['function mint(uint32 tokenId) nonpayable']),
-             *   walletClient,
-             * })
-             * const hash = await contract.write.min([69420], {
-             *   address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',
-             * })
-             */
-            write: {
-              [FunctionName in _WriteFunctionNames]: GetWriteFunction<
-                _Narrowable,
-                TWalletClient['chain'],
-                TWalletClient['account'],
-                TAbi,
-                FunctionName
-              >
             }
-          }
-      : unknown)
-> & { address: TAddress; abi: TAbi }
+        : unknown)
+  > & { address: TAddress; abi: TAbi }
+>
 
 /**
  * Gets type-safe interface for performing contract-related actions with a specific `abi` and `address`.
@@ -443,7 +451,7 @@ export function getContract<
           get(_, functionName: string) {
             return (
               ...parameters: [
-                args?: readonly unknown[],
+                args?: readonly unknown[] | undefined,
                 options?: UnionOmit<
                   ReadContractParameters,
                   'abi' | 'address' | 'functionName' | 'args'
@@ -671,7 +679,7 @@ export function getEventParameters(
 type GetReadFunction<
   Narrowable extends boolean,
   TAbi extends Abi | readonly unknown[],
-  TFunctionName extends string,
+  TFunctionName extends ContractFunctionName<TAbi, 'pure' | 'view'>,
   TAbiFunction extends AbiFunction = TAbi extends Abi
     ? ExtractAbiFunction<TAbi, TFunctionName>
     : AbiFunction,

package/src/actions/public/multicall.ts

@@ -7,9 +7,9 @@ import { AbiDecodingZeroDataError } from '../../errors/abi.js'
 import type { BaseError } from '../../errors/base.js'
 import { RawContractError } from '../../errors/contract.js'
 import type { Chain } from '../../types/chain.js'
+import type { ContractFunctionParameters } from '../../types/contract.js'
 import type { Hex } from '../../types/misc.js'
 import type {
-  MulticallContract,
   MulticallContracts,
   MulticallResults,
 } from '../../types/multicall.js'
@@ -17,12 +17,11 @@ import { decodeFunctionResult } from '../../utils/abi/decodeFunctionResult.js'
 import { encodeFunctionData } from '../../utils/abi/encodeFunctionData.js'
 import { getChainContractAddress } from '../../utils/chain.js'
 import { getContractError } from '../../utils/errors/getContractError.js'
-
 import type { CallParameters } from './call.js'
 import { readContract } from './readContract.js'
 
 export type MulticallParameters<
-  contracts extends readonly unknown[] = readonly MulticallContract[],
+  contracts extends readonly unknown[] = readonly ContractFunctionParameters[],
   allowFailure extends boolean = true,
   options extends {
     optional?: boolean
@@ -39,7 +38,7 @@ export type MulticallParameters<
 }
 
 export type MulticallReturnType<
-  contracts extends readonly unknown[] = readonly MulticallContract[],
+  contracts extends readonly unknown[] = readonly ContractFunctionParameters[],
   allowFailure extends boolean = true,
   options extends {
     error?: Error
@@ -104,7 +103,7 @@ export async function multicall<
     blockTag,
     multicallAddress: multicallAddress_,
   } = parameters
-  const contracts = parameters.contracts as MulticallContract[]
+  const contracts = parameters.contracts as ContractFunctionParameters[]
 
   const batchSize =
     batchSize_ ??

package/src/actions/public/readContract.ts

@@ -5,8 +5,10 @@ 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,
@@ -17,19 +19,34 @@ import {
   encodeFunctionData,
 } from '../../utils/abi/encodeFunctionData.js'
 import { getContractError } from '../../utils/errors/getContractError.js'
-
 import { type CallParameters, call } from './call.js'
 
 export type ReadContractParameters<
   abi extends Abi | readonly unknown[] = Abi,
-  functionName extends string = string,
+  functionName extends ContractFunctionName<
+    abi,
+    'pure' | 'view'
+  > = ContractFunctionName<abi, 'pure' | 'view'>,
+  args extends ContractFunctionArgs<
+    abi,
+    'pure' | 'view',
+    functionName
+  > = ContractFunctionArgs<abi, 'pure' | 'view', functionName>,
 > = Pick<CallParameters, 'account' | 'blockNumber' | 'blockTag'> &
-  ContractFunctionConfig<abi, functionName, 'view' | 'pure'>
+  ContractFunctionParameters<abi, 'pure' | 'view', functionName, args>
 
 export type ReadContractReturnType<
-  TAbi extends Abi | readonly unknown[] = Abi,
-  TFunctionName extends string = string,
-> = ContractFunctionResult<TAbi, TFunctionName>
+  abi extends Abi | readonly unknown[] = Abi,
+  functionName extends ContractFunctionName<
+    abi,
+    'pure' | 'view'
+  > = ContractFunctionName<abi, 'pure' | 'view'>,
+  args extends ContractFunctionArgs<
+    abi,
+    'pure' | 'view',
+    functionName
+  > = ContractFunctionArgs<abi, 'pure' | 'view', functionName>,
+> = ContractFunctionReturnType<abi, 'pure' | 'view', functionName, args>
 
 /**
  * Calls a read-only function on a contract, and returns the response.
@@ -65,11 +82,12 @@ export type ReadContractReturnType<
 export async function readContract<
   chain extends Chain | undefined,
   const abi extends Abi | readonly unknown[],
-  functionName extends string,
+  functionName extends ContractFunctionName<abi, 'pure' | 'view'>,
+  args extends ContractFunctionArgs<abi, 'pure' | 'view', functionName>,
 >(
   client: Client<Transport, chain>,
-  parameters: ReadContractParameters<abi, functionName>,
-): Promise<ReadContractReturnType<abi, functionName>> {
+  parameters: ReadContractParameters<abi, functionName, args>,
+): Promise<ReadContractReturnType<abi, functionName, args>> {
   const { abi, address, args, functionName, ...callRequest } = parameters
   const calldata = encodeFunctionData({
     abi,

package/src/clients/decorators/public.ts

@@ -200,6 +200,8 @@ import type { Account } from '../../types/account.js'
 import type { BlockNumber, BlockTag } from '../../types/block.js'
 import type { Chain } from '../../types/chain.js'
 import type {
+  ContractFunctionArgs,
+  ContractFunctionName,
   MaybeAbiEventName,
   MaybeExtractEventArgsFromAbi,
 } from '../../types/contract.js'
@@ -1169,11 +1171,12 @@ export type PublicActions<
    * // 424122n
    */
   readContract: <
-    const TAbi extends Abi | readonly unknown[],
-    TFunctionName extends string,
+    const abi extends Abi | readonly unknown[],
+    functionName extends ContractFunctionName<abi, 'pure' | 'view'>,
+    args extends ContractFunctionArgs<abi, 'pure' | 'view', functionName>,
   >(
-    args: ReadContractParameters<TAbi, TFunctionName>,
-  ) => Promise<ReadContractReturnType<TAbi, TFunctionName>>
+    args: ReadContractParameters<abi, functionName, args>,
+  ) => Promise<ReadContractReturnType<abi, functionName, args>>
   /**
    * Simulates/validates a contract interaction. This is useful for retrieving **return data** and **revert reasons** of contract write functions.
    *

package/src/index.ts

@@ -515,6 +515,10 @@ export { SizeExceedsPaddingSizeError } from './errors/data.js'
 export { UrlRequiredError } from './errors/transport.js'
 export type {
   AbiItem,
+  ContractFunctionParameters,
+  ContractFunctionReturnType,
+  ContractFunctionName,
+  ContractFunctionArgs,
   ContractParameters,
   ContractReturnType,
   ContractFunctionConfig,
@@ -636,7 +640,6 @@ export type { GetTransportConfig } from './types/transport.js'
 export type { HDKey } from '@scure/bip32'
 export type { Log } from './types/log.js'
 export type {
-  MulticallContract,
   MulticallContracts,
   MulticallResponse,
   MulticallResults,