feat(human-readable): parameter validation and strict mode

docs/config.md

@@ -151,17 +151,17 @@ declare module 'abitype' {
 }
 ```
 
-### `StrictAbiType`
+### `Strict`
 
-When set, validates `AbiParameter`'s `type` against `AbiType`.
+When set, validates `AbiParameter`'s `type` against `AbiType` and enforces stricter checks on human readable ABIs.
 
 - Type `boolean`
 - Default `false`
 
 ```ts twoslash
 declare module 'abitype' {
   export interface Config {
-    StrictAbiType: false
+    Strict: false
   }
 }
 ```

src/abi.ts

@@ -84,8 +84,8 @@ export type AbiType =
   | SolidityInt
   | SolidityString
   | SolidityTuple
-type ResolvedAbiType = ResolvedConfig['StrictAbiType'] extends true
-  ? AbiType
+type ResolvedAbiType = ResolvedConfig['Strict'] extends true
+  ? AbiType & string
   : string
 
 export type AbiInternalType =
@@ -95,6 +95,21 @@ export type AbiInternalType =
   | `enum ${string}`
   | `struct ${string}`
 
+export type InferredAbiParameter = Prettify<
+  {
+    type: string
+    name?: string | undefined
+    /** Representation used by Solidity compiler */
+    internalType?: string | undefined
+  } & (
+    | { type: string }
+    | {
+        type: string
+        components: readonly InferredAbiParameter[]
+      }
+  )
+>
+
 export type AbiParameter = Prettify<
   {
     type: ResolvedAbiType

src/config.test-d.ts

@@ -3,9 +3,9 @@ import { assertType, test } from 'vitest'
 import type { ResolvedConfig } from './config.js'
 
 // For testing updates to config properties:
-// declare module './config' {
+// declare module './config.js' {
 //   export interface Config {
-//     FixedArrayMaxLength: 6
+//     Strict: true
 //   }
 // }
 
@@ -29,6 +29,6 @@ test('Config', () => {
   type BigIntType = ResolvedConfig['BigIntType']
   assertType<BigIntType>(123n)
 
-  type StrictAbiType = ResolvedConfig['StrictAbiType']
-  assertType<StrictAbiType>(false)
+  type Strict = ResolvedConfig['Strict']
+  assertType<Strict>(false)
 })

src/config.ts

@@ -39,8 +39,8 @@ export interface DefaultConfig {
   /** TypeScript type to use for `int<M>` and `uint<M>` values, where `M <= 48` */
   IntType: number
 
-  /** When set, validates {@link AbiParameter}'s `type` against {@link AbiType} */
-  StrictAbiType: false
+  /** When set, validates {@link AbiParameter}'s `type` against {@link AbiType} and enforces stricter checks on human readable ABIs */
+  Strict: false
 }
 
 /**
@@ -110,14 +110,14 @@ export interface ResolvedConfig {
     : Config['IntType']
 
   /**
-   * When set, validates {@link AbiParameter}'s `type` against {@link AbiType}
+   *  When set, validates {@link AbiParameter}'s `type` against {@link AbiType} and enforces stricter checks on human readable ABIs
    *
    * Note: You probably only want to set this to `true` if parsed types are returning as `unknown`
-   * and you want to figure out why.
+   * and you want to figure out why or if you want stricter validation on your types.
    *
    * @default false
    */
-  StrictAbiType: Config['StrictAbiType'] extends true
-    ? Config['StrictAbiType']
-    : DefaultConfig['StrictAbiType']
+  Strict: Config['Strict'] extends true
+    ? Config['Strict']
+    : DefaultConfig['Strict']
 }

src/human-readable/errors/abiParameter.test.ts

@@ -115,15 +115,15 @@ test('InvalidFunctionModifierError', () => {
 test('InvalidAbiTypeParameterError', () => {
   expect(
     new InvalidAbiTypeParameterError({
-      abiParameter: { type: 'addres' },
+      abiParameter: { type: 'address' },
     }),
   ).toMatchInlineSnapshot(`
     [InvalidAbiTypeParameterError: Invalid ABI parameter.
 
     ABI parameter type is invalid.
 
     Details: {
-      "type": "addres"
+      "type": "address"
     }
     Version: [email protected]]
   `)

src/human-readable/parseAbiParameter.test-d.ts

@@ -55,6 +55,10 @@ test('ParseAbiParameter', () => {
 test('parseAbiParameter', () => {
   // @ts-expect-error empty array not allowed
   expectTypeOf(parseAbiParameter([])).toEqualTypeOf<never>()
+  expectTypeOf(
+    // @ts-expect-error no valid struct arguments
+    parseAbiParameter(['address owner', 'struct Foo { string name; }']),
+  ).toEqualTypeOf<never>()
   expectTypeOf(
     parseAbiParameter(['struct Foo { string name; }']),
   ).toEqualTypeOf<never>()

src/human-readable/parseAbiParameter.ts

@@ -1,6 +1,6 @@
 import type { AbiParameter } from '../abi.js'
 import type { Narrow } from '../narrow.js'
-import type { Error, Filter } from '../types.js'
+import type { Error, Filter, IsEmptyObject } from '../types.js'
 import { InvalidAbiParameterError } from './errors/index.js'
 import {
   isStructSignature,
@@ -15,6 +15,23 @@ import type {
   ParseStructs,
 } from './types/index.js'
 
+export type ValidateAbiParameter<TParams extends readonly string[]> =
+  ParseStructs<TParams> extends infer ParsedStructs extends object
+    ? IsEmptyObject<ParsedStructs> extends true
+      ? Error<'No Struct signature found. Please provide valid struct signatures.'>
+      : {
+          [K in keyof TParams]: IsStructSignature<TParams[K]> extends true
+            ? never
+            : TParams[K] extends `${infer Type} ${string}`
+            ? Type extends keyof ParsedStructs
+              ? never
+              : Error<`Invalid Parameter "${TParams[K]}". Only Struct parameters are allowed`>
+            : TParams[K] extends keyof ParsedStructs
+            ? never
+            : Error<`Invalid Parameter "${TParams[K]}". Only Struct parameters are allowed`>
+        }
+    : unknown
+
 /**
  * Parses human-readable ABI parameter into {@link AbiParameter}
  *
@@ -44,21 +61,25 @@ export type ParseAbiParameter<
   | (TParam extends readonly string[]
       ? string[] extends TParam
         ? AbiParameter // Return generic AbiParameter item since type was no inferrable
-        : ParseStructs<TParam> extends infer Structs
-        ? {
-            [K in keyof TParam]: TParam[K] extends string
-              ? IsStructSignature<TParam[K]> extends true
-                ? never
-                : ParseAbiParameter_<
-                    TParam[K],
-                    { Modifier: Modifier; Structs: Structs }
-                  >
+        : ValidateAbiParameter<TParam> extends infer Validated
+        ? Validated extends never[]
+          ? ParseStructs<TParam> extends infer Structs
+            ? {
+                [K in keyof TParam]: TParam[K] extends string
+                  ? IsStructSignature<TParam[K]> extends true
+                    ? never
+                    : ParseAbiParameter_<
+                        TParam[K],
+                        { Modifier: Modifier; Structs: Structs }
+                      >
+                  : never
+              } extends infer Mapped extends readonly unknown[]
+              ? Filter<Mapped, never>[0] extends infer Result
+                ? Result extends undefined
+                  ? never
+                  : Result
+                : never
               : never
-          } extends infer Mapped extends readonly unknown[]
-          ? Filter<Mapped, never>[0] extends infer Result
-            ? Result extends undefined
-              ? never
-              : Result
             : never
           : never
         : never
@@ -96,7 +117,11 @@ export function parseAbiParameter<
             ? Error<'At least one parameter required.'>
             : string[] extends TParam
             ? unknown
-            : unknown // TODO: Validate param string
+            : ValidateAbiParameter<TParam> extends infer ValidatedParams extends readonly unknown[]
+            ? ValidatedParams extends never[]
+              ? unknown
+              : ValidatedParams
+            : never
           : never)
     ),
 ): ParseAbiParameter<TParam> {

src/human-readable/parseAbiParameters.test-d.ts

@@ -94,6 +94,7 @@ test('parseAbiParameters', () => {
   // @ts-expect-error empty array not allowed
   expectTypeOf(parseAbiParameters([])).toEqualTypeOf<never>()
   expectTypeOf(
+    // @ts-expect-error invalid no parameter given
     parseAbiParameters(['struct Foo { string name; }']),
   ).toEqualTypeOf<never>()
 

src/human-readable/parseAbiParameters.test.ts

@@ -24,6 +24,7 @@ test('parseAbiParameters', () => {
   `,
   )
   expect(() =>
+    // @ts-expect-error invalid no parameter given
     parseAbiParameters(['struct Foo { string name; }']),
   ).toThrowErrorMatchingInlineSnapshot(
     `

src/human-readable/parseAbiParameters.ts

@@ -1,6 +1,7 @@
 import type { AbiParameter } from '../abi.js'
 import type { Narrow } from '../narrow.js'
-import type { Error, Filter } from '../types.js'
+import type { Error, Filter, Flatten } from '../types.js'
+import type { ExtractAbiParseErrors } from '../utils.js'
 import { InvalidAbiParametersError } from './errors/index.js'
 import {
   isStructSignature,
@@ -17,6 +18,10 @@ import type {
   SplitParameters,
 } from './types/index.js'
 
+export type ValidateAbiParameters<T extends readonly string[]> =
+  ParseAbiParameters<T> extends infer ParsedParams extends readonly unknown[]
+    ? Flatten<ExtractAbiParseErrors<ParsedParams>>
+    : never
 /**
  * Parses human-readable ABI parameters into {@link AbiParameter}s
  *
@@ -98,7 +103,13 @@ export function parseAbiParameters<
             ? Error<'At least one parameter required.'>
             : string[] extends TParams
             ? unknown
-            : unknown // TODO: Validate param string
+            : ValidateAbiParameters<TParams> extends infer Parsed
+            ? Parsed extends readonly []
+              ? unknown
+              : Parsed extends readonly string[]
+              ? Parsed[number]
+              : Parsed
+            : never
           : never)
     ),
 ): ParseAbiParameters<TParams> {

src/human-readable/types/signatures.ts

@@ -1,4 +1,5 @@
 import type { AbiStateMutability } from '../../abi.js'
+import type { ResolvedConfig } from '../../config.js'
 import type { Error } from '../../types.js'
 
 export type ErrorSignature<
@@ -128,7 +129,7 @@ export type IsName<TName extends string> = TName extends ''
   : false
 export type ValidateName<
   TName extends string,
-  CheckCharacters extends boolean = false,
+  CheckCharacters extends boolean = ResolvedConfig['Strict'],
 > = TName extends `${string}${' '}${string}`
   ? Error<`Name "${TName}" cannot contain whitespace.`>
   : IsSolidityKeyword<TName> extends true

src/human-readable/types/structs.ts

@@ -1,9 +1,9 @@
-import type { AbiParameter } from '../../abi.js'
+import type { InferredAbiParameter } from '../../abi.js'
 import type { Error, Trim } from '../../types.js'
 import type { StructSignature } from './signatures.js'
 import type { ParseAbiParameter } from './utils.js'
 
-export type StructLookup = Record<string, readonly AbiParameter[]>
+export type StructLookup = Record<string, readonly InferredAbiParameter[]>
 
 export type ParseStructs<TSignatures extends readonly string[]> =
   // Create "shallow" version of each struct (and filter out non-structs or invalid structs)
@@ -16,7 +16,7 @@ export type ParseStructs<TSignatures extends readonly string[]> =
         : never]: ParseStruct<Signature>['components']
   } extends infer Structs extends Record<
     string,
-    readonly (AbiParameter & { type: string })[]
+    readonly (InferredAbiParameter & { type: string })[]
   >
     ? // Resolve nested structs inside each struct
       {
@@ -38,8 +38,11 @@ export type ParseStruct<
   : never
 
 export type ResolveStructs<
-  TAbiParameters extends readonly (AbiParameter & { type: string })[],
-  TStructs extends Record<string, readonly (AbiParameter & { type: string })[]>,
+  TAbiParameters extends readonly (InferredAbiParameter & { type: string })[],
+  TStructs extends Record<
+    string,
+    readonly (InferredAbiParameter & { type: string })[]
+  >,
   TKeyReferences extends { [_: string]: unknown } | unknown = unknown,
 > = readonly [
   ...{
@@ -82,6 +85,6 @@ export type ParseStructProperties<
   ? ParseStructProperties<
       Tail,
       TStructs,
-      [...Result, ParseAbiParameter<Head, { Structs: TStructs }>]
+      [...Result, ParseAbiParameter<Head, { Structs: TStructs; Strict: false }>]
     >
   : Result