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

package/src/types/contract.ts

@@ -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 []

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

@@ -183,7 +183,7 @@ export type IsUnion<
 export type MaybePartial<
   type,
   enabled extends boolean | undefined,
-> = enabled extends true ? ExactPartial<type> : type
+> = enabled extends true ? Prettify<ExactPartial<type>> : type
 
 export type ExactPartial<type> = {
   [key in keyof type]?: type[key] | undefined