viem 0.0.0-w-20230818230619 → 0.0.0-w-20230821160922

package/src/clients/decorators/wallet.ts

@@ -61,6 +61,10 @@ import {
   writeContract,
 } from '../../actions/wallet/writeContract.js'
 import type { Chain } from '../../types/chain.js'
+import {
+  type ContractFunctionArgs,
+  type ContractFunctionName,
+} from '../../types/contract.js'
 import type { Client } from '../createClient.js'
 import type { Transport } from '../transports/createTransport.js'
 
@@ -509,13 +513,15 @@ export type WalletActions<
    * const hash = await client.writeContract(request)
    */
   writeContract: <
-    const TAbi extends Abi | readonly unknown[],
-    TFunctionName extends string,
+    const abi extends Abi | readonly unknown[],
+    functionName extends ContractFunctionName<abi, 'payable' | 'nonpayable'>,
+    args extends ContractFunctionArgs<abi, 'pure' | 'view', functionName>,
     TChainOverride extends Chain | undefined,
   >(
     args: WriteContractParameters<
-      TAbi,
-      TFunctionName,
+      abi,
+      functionName,
+      args,
       TChain,
       TAccount,
       TChainOverride

package/src/index.ts

@@ -515,9 +515,10 @@ export { SizeExceedsPaddingSizeError } from './errors/data.js'
 export { UrlRequiredError } from './errors/transport.js'
 export type {
   AbiItem,
-  ContractParameters,
-  ContractReturnType,
-  ContractFunctionConfig,
+  ContractFunctionParameters,
+  ContractFunctionReturnType,
+  ContractFunctionName,
+  ContractFunctionArgs,
   ContractFunctionResult,
   GetConstructorArgs,
   GetErrorArgs,
@@ -636,7 +637,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,

package/src/types/contract.ts

@@ -1,21 +1,21 @@
-import type {
-  Abi,
-  AbiConstructor,
-  AbiError,
-  AbiEvent,
-  AbiFunction,
-  AbiParameter,
-  AbiParameterToPrimitiveType,
-  AbiParametersToPrimitiveTypes,
-  AbiStateMutability,
-  Address,
-  ExtractAbiError,
-  ExtractAbiErrorNames,
-  ExtractAbiEvent,
-  ExtractAbiEventNames,
-  ExtractAbiFunction,
-  ExtractAbiFunctionNames,
-  ResolvedConfig,
+import {
+  type Abi,
+  type AbiConstructor,
+  type AbiError,
+  type AbiEvent,
+  type AbiFunction,
+  type AbiParameter,
+  type AbiParameterToPrimitiveType,
+  type AbiParametersToPrimitiveTypes,
+  type AbiStateMutability,
+  type Address,
+  type ExtractAbiError,
+  type ExtractAbiErrorNames,
+  type ExtractAbiEvent,
+  type ExtractAbiEventNames,
+  type ExtractAbiFunction,
+  type ExtractAbiFunctionNames,
+  type ResolvedConfig,
 } from 'abitype'
 
 import type { Hex, LogTopic } from './misc.js'
@@ -30,22 +30,37 @@ import type {
   UnionToTuple,
 } from './utils.js'
 
-export type FunctionName<
-  abi extends Abi = Abi,
+export type ContractFunctionName<
+  abi extends Abi | readonly unknown[] = Abi,
   mutability extends AbiStateMutability = AbiStateMutability,
-> = ExtractAbiFunctionNames<abi, mutability>
-
-export type Args<
-  abi extends Abi = Abi,
+> = ExtractAbiFunctionNames<
+  abi extends Abi ? abi : Abi,
+  mutability
+> extends infer functionName extends string
+  ? [functionName] extends [never]
+    ? string
+    : functionName
+  : string
+
+export type ContractFunctionArgs<
+  abi extends Abi | readonly unknown[] = Abi,
   mutability extends AbiStateMutability = AbiStateMutability,
-  functionName extends ExtractAbiFunctionNames<
+  functionName extends ContractFunctionName<
     abi,
     mutability
-  > = ExtractAbiFunctionNames<abi, mutability>,
+  > = ContractFunctionName<abi, mutability>,
 > = AbiParametersToPrimitiveTypes<
-  ExtractAbiFunction<abi, functionName, mutability>['inputs'],
+  ExtractAbiFunction<
+    abi extends Abi ? abi : Abi,
+    functionName,
+    mutability
+  >['inputs'],
   'inputs'
->
+> extends infer args
+  ? [args] extends [never]
+    ? readonly unknown[]
+    : args
+  : readonly unknown[]
 
 export type Widen<type> =
   | ([unknown] extends [type] ? unknown : never)
@@ -75,8 +90,8 @@ export type Widen<type> =
 export type ExtractAbiFunctionForArgs<
   abi extends Abi,
   mutability extends AbiStateMutability,
-  functionName extends FunctionName<abi, mutability>,
-  args extends Args<abi, mutability, functionName>,
+  functionName extends ContractFunctionName<abi, mutability>,
+  args extends ContractFunctionArgs<abi, mutability, functionName>,
 > = ExtractAbiFunction<
   abi,
   functionName,
@@ -96,14 +111,59 @@ export type ExtractAbiFunctionForArgs<
     : abiFunction
   : never
 
+export type ContractFunctionParameters<
+  abi extends Abi | readonly unknown[] = Abi,
+  mutability extends AbiStateMutability = AbiStateMutability,
+  functionName extends ContractFunctionName<
+    abi,
+    mutability
+  > = ContractFunctionName<abi, mutability>,
+  args extends ContractFunctionArgs<
+    abi,
+    mutability,
+    functionName
+  > = ContractFunctionArgs<abi, mutability, functionName>,
+  ///
+  allArgs = ContractFunctionArgs<abi, mutability, functionName>,
+  allFunctionNames = ContractFunctionName<abi, mutability>,
+  // when `args` is inferred to `readonly []` ("inputs": []) or `never` (`abi` declared as `Abi` or not inferrable), allow `args` to be optional.
+  // important that both branches return same structural type
+> = readonly [] extends allArgs
+  ? {
+      address: Address
+      abi: abi
+      functionName:
+        | allFunctionNames // show all options
+        | (functionName extends allFunctionNames ? functionName : never) // infer value
+      args?:
+        | allArgs // show all options
+        | (args extends allArgs ? Widen<args> : never) // infer value, widen inferred value of `args` conditionally to match `allArgs`
+        | undefined
+    }
+  : {
+      address: Address
+      abi: abi
+      functionName:
+        | allFunctionNames // show all options
+        | (functionName extends allFunctionNames ? functionName : never) // infer value
+      args:
+        | allArgs // show all options
+        | Widen<args> // infer value, widen inferred value of `args` match `allArgs` (e.g. avoid union `args: readonly [123n] | readonly [bigint]`)
+    }
+
 export type ContractFunctionReturnType<
-  contract,
-  mutability extends AbiStateMutability,
-> = contract extends {
-  abi: infer abi extends Abi
-  functionName?: infer functionName extends string
-  args?: infer args
-}
+  abi extends Abi | readonly unknown[] = Abi,
+  mutability extends AbiStateMutability = AbiStateMutability,
+  functionName extends ContractFunctionName<
+    abi,
+    mutability
+  > = ContractFunctionName<abi, mutability>,
+  args extends ContractFunctionArgs<
+    abi,
+    mutability,
+    functionName
+  > = ContractFunctionArgs<abi, mutability, functionName>,
+> = abi extends Abi
   ? Abi extends abi
     ? unknown
     : AbiParametersToPrimitiveTypes<
@@ -111,14 +171,7 @@ export type ContractFunctionReturnType<
           abi,
           mutability,
           functionName,
-          // fallback to `readonly []` if `args` is not defined (e.g. not required `"inputs": []`)
-          (
-            readonly [] extends args
-              ? readonly []
-              : args
-          ) extends infer args2 extends Args<abi, mutability, functionName>
-            ? args2
-            : never
+          readonly [] extends args ? readonly [] : args
         >['outputs']
       > extends infer types
     ? types extends readonly []
@@ -133,78 +186,6 @@ export type AbiItem = Abi[number]
 
 export type EventDefinition = `${string}(${string})`
 
-export type ContractParameters<
-  abi extends Abi | readonly unknown[] = readonly unknown[],
-  stateMutability extends AbiStateMutability = AbiStateMutability,
-  functionName extends ExtractAbiFunctionNames<
-    abi extends Abi ? abi : Abi,
-    stateMutability
-  > = string,
-  ///
-  functionNames extends string = abi extends Abi
-    ? ExtractAbiFunctionNames<abi, stateMutability>
-    : string,
-  abiFunction extends AbiFunction = abi extends Abi
-    ? ExtractAbiFunction<
-        abi,
-        functionName extends functionNames ? functionName : functionNames, // fallback to all function names if `functionName` is invalid
-        stateMutability
-      >
-    : AbiFunction,
-  types = AbiParametersToPrimitiveTypes<abiFunction['inputs'], 'inputs'>,
-  args =
-    | types // show all values
-    | (Abi extends abi ? readonly unknown[] | undefined : never) // `abi` declared as `Abi`
-    | (readonly [] extends types ? undefined : never), // `abiFunction` has no inputs
-  isArgsOptional extends boolean = Abi extends abi
-    ? true
-    : readonly [] extends types
-    ? true
-    : false,
-> = {
-  abi: abi
-  address: Address
-  functionName:
-    | functionNames // show all values
-    | (functionName extends functionNames ? functionName : never) // validate `functionName`
-    | ([functionNames] extends [never] ? string : never) // `abi` declared as `Abi`
-} & (isArgsOptional extends true ? { args?: args | undefined } : { args: args })
-
-export type ContractReturnType<
-  abi extends Abi | readonly unknown[] = readonly unknown[],
-  stateMutability extends AbiStateMutability = AbiStateMutability,
-  functionName extends ExtractAbiFunctionNames<
-    abi extends Abi ? abi : Abi,
-    stateMutability
-  > = string,
-  ///
-  abiFunction extends AbiFunction = abi extends Abi
-    ? ExtractAbiFunction<abi, functionName, stateMutability>
-    : AbiFunction,
-  types = AbiParametersToPrimitiveTypes<abiFunction['outputs'], 'outputs'>,
-> = [abiFunction] extends [never]
-  ? unknown // `abiFunction` was not inferrable (e.g. `abi` declared as `Abi`)
-  : readonly unknown[] extends types
-  ? unknown // `abiFunction` was not inferrable (e.g. `abi` not const asserted)
-  : types extends readonly [] // unwrap `types`
-  ? void // no outputs
-  : types extends readonly [infer type]
-  ? type // single output
-  : types
-
-export type ContractFunctionConfig<
-  TAbi extends Abi | readonly unknown[] = Abi,
-  TFunctionName extends string = string,
-  TAbiStateMutability extends AbiStateMutability = AbiStateMutability,
-> = {
-  /** Contract ABI */
-  abi: TAbi
-  /** Contract address */
-  address: Address
-  /** Function to invoke on the contract */
-  functionName: InferFunctionName<TAbi, TFunctionName, TAbiStateMutability>
-} & GetFunctionArgs<TAbi, TFunctionName>
-
 export type ContractFunctionResult<
   TAbi extends Abi | readonly unknown[] = Abi,
   TFunctionName extends string = string,

package/src/types/multicall.ts

@@ -1,48 +1,13 @@
-import type { Abi, AbiStateMutability, Address } from 'abitype'
+import type { Abi, AbiStateMutability } from 'abitype'
 
 import type {
-  Args,
+  ContractFunctionArgs,
+  ContractFunctionName,
+  ContractFunctionParameters,
   ContractFunctionReturnType,
-  FunctionName,
-  Widen,
 } from './contract.js'
 import type { MaybePartial } from './utils.js'
 
-export type MulticallContract<
-  abi extends Abi | readonly unknown[] = Abi,
-  mutability extends AbiStateMutability = AbiStateMutability,
-  functionName extends FunctionName<
-    abi extends Abi ? abi : Abi,
-    mutability
-  > = string,
-  args extends Args<
-    abi extends Abi ? abi : Abi,
-    mutability,
-    functionName
-  > = Args<abi extends Abi ? abi : Abi, mutability, functionName>,
-> = readonly [] extends args
-  ? {
-      address: Address
-      abi: abi
-      functionName:
-        | functionName
-        | FunctionName<abi extends Abi ? abi : Abi, mutability>
-      args?:
-        | Widen<args>
-        | Args<abi extends Abi ? abi : Abi, mutability, functionName>
-        | undefined
-    }
-  : {
-      address: Address
-      abi: abi
-      functionName:
-        | functionName
-        | FunctionName<abi extends Abi ? abi : Abi, mutability>
-      args:
-        | Widen<args>
-        | Args<abi extends Abi ? abi : Abi, mutability, functionName>
-    }
-
 export type MulticallContracts<
   contracts extends readonly unknown[],
   options extends {
@@ -52,71 +17,58 @@ export type MulticallContracts<
   } = { mutability: AbiStateMutability },
   ///
   result extends readonly any[] = [],
-> = contracts extends readonly []
+> = contracts extends readonly [] // no contracts, return empty
   ? readonly []
-  : contracts extends readonly [infer contract] // One contract left before returning `result`
+  : contracts extends readonly [infer contract] // one contract left before returning `result`
   ? readonly [
       ...result,
-      GetMulticallContract<contract, options['mutability']> extends [never] // If `GetContract` returns `never`, then `contract` is invalid
-        ? // Fallback to just `abi`
-          MaybePartial<
-            Omit<MulticallContract, 'args'> & {
-              args?: readonly unknown[] | undefined
-            } & options['properties'],
-            options['optional']
-          >
-        : // We know `contract` is inferrable, let's get to it!
-          MaybePartial<
-            GetMulticallContract<contract, options['mutability']> &
-              options['properties'],
-            options['optional']
-          >,
+      MaybePartial<
+        GetMulticallContractParameters<contract, options['mutability']> &
+          options['properties'],
+        options['optional']
+      >,
     ]
-  : contracts extends readonly [infer contract, ...infer rest] // Grab first contract and recurse
+  : contracts extends readonly [infer contract, ...infer rest] // grab first contract and recurse through `rest`
   ? MulticallContracts<
       [...rest],
       options,
       [
         ...result,
-        GetMulticallContract<contract, options['mutability']> extends [never] // If `GetContract` returns `never`, then `contract` is invalid
-          ? // Fallback to just `abi`
-            MaybePartial<
-              Omit<MulticallContract, 'args'> & {
-                args?: readonly unknown[] | undefined
-              } & options['properties'],
-              options['optional']
-            >
-          : // We know `contract` is inferrable, let's get to it!
-            MaybePartial<
-              GetMulticallContract<contract, options['mutability']> &
-                options['properties'],
-              options['optional']
-            >,
+        MaybePartial<
+          GetMulticallContractParameters<contract, options['mutability']> &
+            options['properties'],
+          options['optional']
+        >,
       ]
     >
   : readonly unknown[] extends contracts
   ? contracts
   : // If `contracts` is *some* array but we couldn't assign `unknown[]` to it, then it must hold some known/homogenous type!
   // use this to infer the param types in the case of Array.map() argument
-  contracts extends readonly MulticallContract<
+  contracts extends readonly ContractFunctionParameters<
       infer abi,
       infer _,
       infer functionName,
       infer args
     >[]
   ? readonly MaybePartial<
-      MulticallContract<abi, options['mutability'], functionName, args> &
+      ContractFunctionParameters<
+        abi,
+        options['mutability'],
+        functionName,
+        args
+      > &
         options['properties'],
       options['optional']
     >[]
   : // Fallback
     readonly MaybePartial<
-      MulticallContract & options['properties'],
+      ContractFunctionParameters & options['properties'],
       options['optional']
     >[]
 
 export type MulticallResults<
-  contracts extends readonly unknown[] = readonly MulticallContract[],
+  contracts extends readonly unknown[] = readonly ContractFunctionParameters[],
   allowFailure extends boolean = true,
   options extends {
     error?: Error
@@ -124,14 +76,7 @@ export type MulticallResults<
   } = { error: Error; mutability: AbiStateMutability },
 > = {
   [index in keyof contracts]: MulticallResponse<
-    ContractFunctionReturnType<
-      contracts[index],
-      options['mutability']
-    > extends infer result
-      ? [result] extends [never]
-        ? unknown
-        : result
-      : unknown,
+    GetMulticallContractReturnType<contracts[index], options['mutability']>,
     options['error'],
     allowFailure
   >
@@ -151,54 +96,55 @@ export type MulticallResponse<
         }
   : result
 
-type GetMulticallContract<
+// infer contract parameters from `unknown`
+type GetMulticallContractParameters<
   contract,
   mutability extends AbiStateMutability,
-> = contract extends { abi: infer abi extends Abi } // 1. Check if `abi` is const-asserted, defined inline, or declared as `Abi`
+> = contract extends { abi: infer abi extends Abi } // 1. Check if `abi` is const-asserted or defined inline
   ? // 1a. Check if `functionName` is valid for `abi`
     contract extends {
-      functionName: infer functionName extends FunctionName<abi, mutability>
+      functionName: infer functionName extends ContractFunctionName<
+        abi,
+        mutability
+      >
     }
     ? // 1aa. Check if `args` is valid for `abi` and `functionName`
       contract extends {
-        args: infer args extends Args<abi, mutability, functionName>
+        args: infer args extends ContractFunctionArgs<
+          abi,
+          mutability,
+          functionName
+        >
       }
-      ? // 1aa. Check if `args` can be empty
-        readonly [] extends Args<abi, mutability, functionName>
-        ? // `args` can be empty, mark `args` as `undefined`
-          MulticallContract<abi, mutability, functionName, readonly []>
-        : // `contract` is valid as-is, return it
-          MulticallContract<abi, mutability, functionName, args>
-      : // 1ab. `args` is invalid, infer types for `args`
-      readonly [] extends Args<abi, mutability, functionName>
-      ? // `args` can be empty, mark `args` as `undefined`
-        MulticallContract<abi, mutability, functionName, readonly []>
-      : // infer `args`
-        MulticallContract<abi, mutability, functionName>
+      ? ContractFunctionParameters<abi, mutability, functionName, args> // `args` valid, pass through
+      : ContractFunctionParameters<abi, mutability, functionName> // invalid `args`
     : // 1b. `functionName` is invalid, check if `abi` is declared as `Abi`
     Abi extends abi
-    ? // `abi` declared as `Abi`, unable to infer types further
-      MulticallContract
+    ? ContractFunctionParameters // `abi` declared as `Abi`, unable to infer types further
     : // `abi` is const-asserted or defined inline, infer types for `functionName` and `args`
-      Omit<MulticallContract<abi, mutability>, 'args' | 'functionName'> & {
-        // setting `functionName` directly here because `MulticallContract` will allow invalid inputs otherwise (because of `functionName: functionName`)
-        functionName: FunctionName<abi, mutability>
-        // setting `args` directly here because `MulticallContract` has `Widen` in its definition,
-        // which will cause that to show up in editor autocomplete for overloaded functions
-        args: Args<abi, mutability, FunctionName<abi, mutability>>
-      }
-  : // 2. Check if `abi` property exists in `contract`
-  contract extends { abi: infer abi }
-  ? // 2a. `abi` exists in `contract`, check if `abi` is of type `Abi`
-    abi extends Abi
-    ? // return `unknown` since 1 handle type inference
-      MulticallContract
-    : // return default type since `abi` is not inferrable
-      Omit<MulticallContract<readonly unknown[], mutability>, 'args'> & {
-        // setting ars directly here because `MulticallContract` has `Widen` in its definition,
-        // which will cause `never[]` to be inferred for `args` in this case
-        args?: readonly unknown[] | undefined
+      ContractFunctionParameters<abi, mutability>
+  : ContractFunctionParameters<readonly unknown[]> // invalid `contract['abi']`, set to `readonly unknown[]`
+
+type GetMulticallContractReturnType<
+  contract,
+  mutability extends AbiStateMutability,
+> = contract extends { abi: infer abi extends Abi } // 1. Check if `abi` is const-asserted or defined inline
+  ? // Check if `functionName` is valid for `abi`
+    contract extends {
+      functionName: infer functionName extends ContractFunctionName<
+        abi,
+        mutability
+      >
+    }
+    ? // Check if `args` is valid for `abi` and `functionName`
+      contract extends {
+        args: infer args extends ContractFunctionArgs<
+          abi,
+          mutability,
+          functionName
+        >
       }
-  : // 2b. `abi` property does not exist in `contract`, unable to infer types further
-    // return `never`
-    never
+      ? ContractFunctionReturnType<abi, mutability, functionName, args> // `args` valid, pass through
+      : ContractFunctionReturnType<abi, mutability, functionName> // invalid `args`
+    : ContractFunctionReturnType<abi, mutability> // Invalid `functionName`
+  : ContractFunctionReturnType // invalid `contract['abi']` (not const-asserted or declared as `Abi`)

package/src/types/utils.ts

@@ -188,3 +188,12 @@ export type MaybePartial<
 export type ExactPartial<type> = {
   [key in keyof type]?: type[key] | undefined
 }
+
+export type OneOf<
+  union extends object,
+  ///
+  keys extends KeyofUnion<union> = KeyofUnion<union>,
+> = union extends infer Item
+  ? Prettify<Item & { [K in Exclude<keys, keyof Item>]?: undefined }>
+  : never
+type KeyofUnion<type> = type extends type ? keyof type : never