Allow mapping of Structs to user defined types through the config Registry

[architect-dev]

Hello, thanks for the great package, its made my life so much easier. I'm working on a tool that requires both frontend and contract integration, and I've found that I would love to ability to match AbiParameters to custom types via the struct's internalType

Take these two structs for example:

struct inEuint8 {
    bytes data;
}
struct inEuint32 {
    bytes data;
}

They share the same overall structure, but are named differently to improve readability and DX of contract engineers. When they are used as an input param of a function, they look like this in the abi:

"inputs": [
        {
          "components": [
            {
              "internalType": "bytes",
              "name": "data",
              "type": "bytes"
            }
          ],
          "internalType": "struct inEuint32", // or "struct inEuint8"
          "name": "encryptedValue",
          "type": "tuple"
        }
      ],

I would like to be able to catch these internalTypes and apply a type to each before they get treated as tuples and merged into a shared { 0xString }. I think that a good place to do this would be leveraging the ResolvedRegistry. I've set up a crude (but working) example here:

register.ts

export type ResolvedRegister = {
  internalTypePrimitives: {
    'inEuint8': "EncryptedUint8",
    'inEuint32': "EncryptedUint32"
  }
  
  ...
}

utils.ts

import type { ResolvedRegister } from './register.js'

// Extract types from Register for matching

type InternalTypePrimitives = ResolvedRegister['internalTypePrimitives']
type InternalTypeStructMap = { [P in keyof InternalTypePrimitives & string as `struct ${P}`]: InternalTypePrimitives[P] };
type InternalTypeStructUnion = keyof InternalTypeStructMap

...

export type AbiParameterToPrimitiveType<
  abiParameter extends AbiParameter | { name: string; type: unknown, internalType?: unknown }, // Add `internalType?: unknown`
  abiParameterKind extends AbiParameterKind = AbiParameterKind,
 > = abiParameter['type'] extends AbiBasicType
  ? AbiTypeToPrimitiveType<abiParameter['type'], abiParameterKind>
  
  // Check the internal type here against the types passed in through the Registry

  : abiParameter['internalType'] extends InternalTypeStructUnion
  ? InternalTypeStructMap[abiParameter['internalType']]
    
  ...
    

Which gives these results:

type TestUint8Type = AbiParameterToPrimitiveType<{
//    ^? : type TestUint8Type = "EncryptedUint8"
  "components": [
    {
      "internalType": "bytes",
      "name": "data",
      "type": "bytes"
    }
  ],
  "internalType": "struct inEuint8",
  "name": "encryptedValue",
  "type": "tuple"
}>

type TestUint32Type = AbiParameterToPrimitiveType<{
//    ^? : type TestUint32Type = "EncryptedUint32"
  "components": [
    {
      "internalType": "bytes",
      "name": "data",
      "type": "bytes"
    }
  ],
  "internalType": "struct inEuint32",
  "name": "encryptedValue",
  "type": "tuple"
}>

I think this is very niche, but allows a lot of expressiveness for library authors. Let me know what you think!

• Arch