refactor: contract function types

package.json

@@ -48,7 +48,7 @@
  "rome": "^12.1.3",
  "simple-git-hooks": "^2.8.1",
  "typescript": "5.0.4",
- "viem": "0.0.0-w-20230818230619",
+ "viem": "0.0.0-w-20230821171049",
  "vite": "^4.3.9",
  "vitest": "^0.34.1"
  },
@@ -60,7 +60,7 @@
  "overrides": {
  "@wagmi/connectors": "workspace:*",
  "@wagmi/core": "workspace:*",
- "viem": "0.0.0-w-20230818230619"
+ "viem": "0.0.0-w-20230821171049"
  },
  "patchedDependencies": {
  "vitepress@1.0.0-rc.4": "patches/vitepress@1.0.0-rc.4.patch"

packages/core/src/actions/multicall.test-d.ts

@@ -77,14 +77,8 @@ test('MulticallParameters', async () => {
  ]
  >
  >[1]['contracts'][0]
- expectTypeOf<Result>().toEqualTypeOf<{
- address: Address
- abi: typeof abi
- functionName: 'foo' | 'bar'
- args?:
- | readonly []
- | readonly [Address]
- | readonly [Address, Address]
- | undefined
- }>()
+ expectTypeOf<Result['functionName']>().toEqualTypeOf<'foo' | 'bar'>()
+ expectTypeOf<Result['args']>().toEqualTypeOf<
+ readonly [] | readonly [Address] | readonly [Address, Address] | undefined
+ >()
 })

packages/core/src/actions/multicall.ts

@@ -1,6 +1,5 @@
 import type {
- ContractParameters,
- MulticallContract,
+ ContractFunctionParameters,
  MulticallParameters as viem_MulticallParameters,
  MulticallReturnType as viem_MulticallReturnType,
 } from 'viem'
@@ -11,18 +10,18 @@ import type { ChainIdParameter } from '../types/properties.js'
 
 export type MulticallParameters<
  config extends Config = Config,
- contracts extends readonly unknown[] = readonly MulticallContract[],
+ contracts extends readonly unknown[] = readonly ContractFunctionParameters[],
  allowFailure extends boolean = true,
 > = viem_MulticallParameters<contracts, allowFailure> & ChainIdParameter<config>
 
 export type MulticallReturnType<
- contracts extends readonly unknown[] = readonly MulticallContract[],
+ contracts extends readonly unknown[] = readonly ContractFunctionParameters[],
  allowFailure extends boolean = true,
 > = viem_MulticallReturnType<contracts, allowFailure>
 
 export async function multicall<
  config extends Config,
- const contracts extends readonly ContractParameters[],
+ const contracts extends readonly unknown[],
  allowFailure extends boolean = true,
 >(
  config: config,

packages/core/src/actions/readContract.ts

@@ -1,4 +1,5 @@
-import { type Abi, type ExtractAbiFunctionNames } from 'viem'
+import { type Abi } from 'viem'
+import type { ContractFunctionArgs, ContractFunctionName } from 'viem'
 import {
  type ReadContractParameters as viem_ReadContractParameters,
  type ReadContractReturnType as viem_ReadContractReturnType,
@@ -11,29 +12,44 @@ import type { ChainIdParameter } from '../types/properties.js'
 export type ReadContractParameters<
  config extends Config = Config,
  abi extends Abi | readonly unknown[] = Abi,
- functionName extends ExtractAbiFunctionNames<
- abi extends Abi ? abi : Abi,
- 'view' | 'pure'
- > = string,
-> = viem_ReadContractParameters<abi, functionName> & ChainIdParameter<config>
+ functionName extends ContractFunctionName<
+ abi,
+ 'pure' | 'view'
+ > = ContractFunctionName<abi, 'pure' | 'view'>,
+ args extends ContractFunctionArgs<
+ abi,
+ 'pure' | 'view',
+ functionName
+ > = ContractFunctionArgs<abi, 'pure' | 'view', functionName>,
+> = viem_ReadContractParameters<abi, functionName, args> &
+ ChainIdParameter<config>
 
 export type ReadContractReturnType<
  abi extends Abi | readonly unknown[] = Abi,
- functionName extends string = string,
-> = viem_ReadContractReturnType<abi, functionName>
+ functionName extends ContractFunctionName<
+ abi,
+ 'pure' | 'view'
+ > = ContractFunctionName<abi, 'pure' | 'view'>,
+ args extends ContractFunctionArgs<
+ abi,
+ 'pure' | 'view',
+ functionName
+ > = ContractFunctionArgs<abi, 'pure' | 'view', functionName>,
+> = viem_ReadContractReturnType<abi, functionName, args>
 
 export type ReadContractError = Error
 
 /** https://wagmi.sh/core/actions/readContract */
 export function readContract<
  config extends Config,
  const abi extends Abi | readonly unknown[],
- functionName extends string,
+ functionName extends ContractFunctionName<abi, 'pure' | 'view'>,
+ args extends ContractFunctionArgs<abi, 'pure' | 'view', functionName>,
 >(
  config: config,
- parameters: ReadContractParameters<config, abi, functionName>,
-): Promise<ReadContractReturnType<abi, functionName>> {
+ parameters: ReadContractParameters<config, abi, functionName, args>,
+): Promise<ReadContractReturnType<abi, functionName, args>> {
  const { chainId } = parameters
  const client = config.getClient({ chainId })
- return viem_readContract(client, parameters)
+ return viem_readContract(client, parameters as any)
 }

packages/core/src/actions/readContracts.ts

@@ -1,5 +1,5 @@
 import type {
- MulticallContract,
+ ContractFunctionParameters,
  MulticallParameters as viem_MulticallParameters,
  MulticallReturnType as viem_MulticallReturnType,
 } from 'viem'
@@ -12,7 +12,7 @@ import { readContract } from './readContract.js'
 
 export type ReadContractsParameters<
  config extends Config = Config,
- contracts extends readonly unknown[] = readonly MulticallContract[],
+ contracts extends readonly unknown[] = readonly ContractFunctionParameters[],
  allowFailure extends boolean = true,
 > = viem_MulticallParameters<
  contracts,
@@ -21,22 +21,22 @@ export type ReadContractsParameters<
 >
 
 export type ReadContractsReturnType<
- contracts extends readonly unknown[] = readonly MulticallContract[],
+ contracts extends readonly unknown[] = readonly ContractFunctionParameters[],
  allowFailure extends boolean = true,
 > = viem_MulticallReturnType<contracts, allowFailure>
 
 export type ReadContractsError = Error
 
 export async function readContracts<
  config extends Config,
- const contracts extends readonly MulticallContract[],
+ const contracts extends readonly ContractFunctionParameters[],
  allowFailure extends boolean = true,
 >(
  config: config,
  parameters: ReadContractsParameters<config, contracts, allowFailure>,
 ): Promise<ReadContractsReturnType<contracts, allowFailure>> {
  const { allowFailure = true, blockNumber, blockTag, ...rest } = parameters
- const contracts = parameters.contracts as (MulticallContract & {
+ const contracts = parameters.contracts as (ContractFunctionParameters & {
  chainId?: number | undefined
  })[]
 
@@ -50,7 +50,10 @@ export async function readContracts<
  }
  },
  {} as {
- [chainId: number]: { contract: MulticallContract; index: number }[]
+ [chainId: number]: {
+ contract: ContractFunctionParameters
+ index: number
+ }[]
  },
  )
  const promises = () =>

packages/core/src/actions/simulateContract.ts

@@ -1,4 +1,12 @@
-import type { Abi, Account, Address, Chain, ExtractAbiFunction } from 'viem'
+import type {
+ Abi,
+ Account,
+ Address,
+ Chain,
+ ContractFunctionArgs,
+ ContractFunctionName,
+ ExtractAbiFunction,
+} from 'viem'
 import {
  type SimulateContractParameters as viem_SimulateContractParameters,
  type SimulateContractReturnType as viem_SimulateContractReturnType,
@@ -11,51 +19,67 @@ import type {
  ChainIdParameter,
  ConnectorParameter,
 } from '../types/properties.js'
-import type { Evaluate, PartialBy } from '../types/utils.js'
+import type { PartialBy, UnionEvaluate, UnionOmit } from '../types/utils.js'
 import { assertActiveChain } from '../utils/assertActiveChain.js'
 import { getConnectorClient } from './getConnectorClient.js'
 
 export type SimulateContractParameters<
  config extends Config = Config,
  chainId extends config['chains'][number]['id'] | undefined = undefined,
  abi extends Abi | readonly unknown[] = Abi,
- functionName extends string = string,
+ functionName extends ContractFunctionName<
+ abi,
+ 'nonpayable' | 'payable'
+ > = ContractFunctionName<abi, 'nonpayable' | 'payable'>,
+ args extends ContractFunctionArgs<
+ abi,
+ 'nonpayable' | 'payable',
+ functionName
+ > = ContractFunctionArgs<abi, 'nonpayable' | 'payable', functionName>,
  ///
  chains extends readonly Chain[] = SelectChains<config['chains'], chainId>,
 > = {
- [key in keyof chains]: Evaluate<
- Evaluate<
- Omit<
- viem_SimulateContractParameters<
- abi,
- functionName,
- chains[key],
- chains[key]
- >,
- 'chain'
- >
- > &
- ChainIdParameter<config, chainId> &
- ConnectorParameter
- >
+ [key in keyof chains]: UnionEvaluate<
+ UnionOmit<
+ viem_SimulateContractParameters<
+ abi,
+ functionName,
+ args,
+ chains[key],
+ chains[key]
+ >,
+ 'chain'
+ >
+ > &
+ ChainIdParameter<config, chainId> &
+ ConnectorParameter
 }[number]
 
 export type SimulateContractReturnType<
  config extends Config = Config,
  chainId extends config['chains'][number]['id'] | undefined = undefined,
  abi extends Abi | readonly unknown[] = Abi,
- functionName extends string = string,
+ functionName extends ContractFunctionName<
+ abi,
+ 'nonpayable' | 'payable'
+ > = ContractFunctionName<abi, 'nonpayable' | 'payable'>,
+ args extends ContractFunctionArgs<
+ abi,
+ 'nonpayable' | 'payable',
+ functionName
+ > = ContractFunctionArgs<abi, 'nonpayable' | 'payable', functionName>,
  ///
  chains extends readonly Chain[] = SelectChains<config['chains'], chainId>,
 > = {
  [key in keyof chains]: viem_SimulateContractReturnType<
  readonly [ExtractAbiFunction<abi extends Abi ? abi : Abi, functionName>],
  functionName,
+ args,
  chains[key]
  > extends infer type extends viem_SimulateContractReturnType
  ? {
- request: Evaluate<
- Omit<type['request'], 'chain'> &
+ request: UnionEvaluate<
+ UnionOmit<type['request'], 'chain'> &
  PartialBy<
  {
  __mode: 'prepared'
@@ -75,13 +99,27 @@ export type SimulateContractError = Error
 export async function simulateContract<
  config extends Config,
  const abi extends Abi | readonly unknown[],
- functionName extends string,
+ functionName extends ContractFunctionName<abi, 'nonpayable' | 'payable'>,
+ args extends ContractFunctionArgs<
+ abi,
+ 'nonpayable' | 'payable',
+ functionName
+ >,
  chainId extends config['chains'][number]['id'] | undefined = undefined,
 >(
  config: config,
- parameters: SimulateContractParameters<config, chainId, abi, functionName>,
-): Promise<SimulateContractReturnType<config, chainId, abi, functionName>> {
- const { chainId, connector, ...rest } = parameters
+ parameters: SimulateContractParameters<
+ config,
+ chainId,
+ abi,
+ functionName,
+ args
+ >,
+): Promise<
+ SimulateContractReturnType<config, chainId, abi, functionName, args>
+> {
+ const { abi, chainId, connector, ...rest } =
+ parameters as SimulateContractParameters
 
  let account: Address | Account
  let activeChainId: number | undefined
@@ -99,10 +137,11 @@ export async function simulateContract<
  const client = config.getClient({ chainId })
  const { result, request } = await viem_simulateContract(client, {
  ...rest,
+ abi,
  account,
  } as viem_SimulateContractParameters)
 
- const minimizedAbi = (parameters.abi as Abi).filter(
+ const minimizedAbi = abi.filter(
  (abiItem) => 'name' in abiItem && abiItem.name === parameters.functionName,
  )
 
@@ -114,5 +153,11 @@ export async function simulateContract<
  abi: minimizedAbi,
  chainId,
  },
- } as unknown as SimulateContractReturnType<config, chainId, abi, functionName>
+ } as unknown as SimulateContractReturnType<
+ config,
+ chainId,
+ abi,
+ functionName,
+ args
+ >
 }