refactor: avoid using wtype property in constructing generic type info for increased fidelity

- also:
  - refactor: use regular expression to match encoders to the type name

Author: boblat

src/encoders.ts

@@ -6,8 +6,7 @@ import { AssetCls } from './impl/asset'
 
 export interface GenericTypeInfo {
   name: string
-  wtypeName?: string
-  genericArgs?: GenericTypeInfo[]
+  genericArgs?: GenericTypeInfo[] | Record<string, GenericTypeInfo>
 }
 
 type fromBytes<T> = (val: Uint8Array, typeInfo: GenericTypeInfo) => T
@@ -42,23 +41,20 @@ const transactionTypeFromBytes: fromBytes<TransactionType> = (val) => {
 
 export const encoders = {
   account: AccountCls.fromBytes,
-  Account: AccountCls.fromBytes,
   application: ApplicationCls.fromBytes,
-  Application: ApplicationCls.fromBytes,
   asset: AssetCls.fromBytes,
-  Asset: AssetCls.fromBytes,
-  bool: booleanFromBytes,
-  boolean: booleanFromBytes,
+  'bool(ean)?': booleanFromBytes,
   biguint: bigUintFromBytes,
   bytes: bytesFromBytes,
   string: stringFromBytes,
   uint64: uint64FromBytes,
   OnCompleteAction: onCompletionFromBytes,
   TransactionType: transactionTypeFromBytes,
+  // 'Tuple<*>': tupleFromBytes,
 }
 
 export const getEncoder = <T>(typeInfo: GenericTypeInfo): fromBytes<T> => {
-  const encoder = encoders[typeInfo.name as keyof typeof encoders]
+  const encoder = Object.entries(encoders).find(([k, _]) => new RegExp(`^${k}$`, 'i').test(typeInfo.name))?.[1]
   if (!encoder) {
     throw new Error(`No encoder found for type ${typeInfo.name}`)
   }

src/impl/state.ts

@@ -17,7 +17,7 @@ import {
 import { AccountMap } from '../collections/custom-key-map'
 import { MAX_BOX_SIZE } from '../constants'
 import { lazyContext } from '../context-helpers/internal-context'
-import { getEncoder } from '../encoders'
+import { GenericTypeInfo, getEncoder } from '../encoders'
 import { getGenericTypeInfo } from '../runtime-helpers'
 import { asBytes, asBytesCls, asNumber, asUint8Array, conactUint8Arrays, toBytes } from '../util'
 
@@ -131,7 +131,7 @@ export class BoxCls<TValue> {
 
   private get fromBytes() {
     const typeInfo = getGenericTypeInfo(this)
-    const valueType = typeInfo!.genericArgs![0]
+    const valueType = (typeInfo!.genericArgs! as GenericTypeInfo[])[0]
     return (val: Uint8Array) => getEncoder<TValue>(valueType)(val, valueType)
   }
 
@@ -199,7 +199,7 @@ export class BoxMapCls<TKey, TValue> {
 
   private get fromBytes() {
     const typeInfo = getGenericTypeInfo(this)
-    const valueType = typeInfo!.genericArgs![1]
+    const valueType = (typeInfo!.genericArgs! as GenericTypeInfo[])[1]
     return (val: Uint8Array) => getEncoder<TValue>(valueType)(val, valueType)
   }
 

src/subcontexts/contract-context.ts

@@ -33,7 +33,7 @@ interface States {
 }
 
 const isUint64GenericType = (typeInfo: GenericTypeInfo | undefined) => {
-  if (!typeInfo?.genericArgs?.length) return false
+  if (!Array.isArray(typeInfo?.genericArgs) || !typeInfo?.genericArgs?.length) return false
   return typeInfo.genericArgs.some((t) => t.name.toLocaleLowerCase() === 'uint64')
 }
 

src/test-transformer/visitors.ts

@@ -187,22 +187,25 @@ class ClassVisitor {
   }
 }
 
-const getGenericTypeInfo = (type: PType | PType['wtype']): GenericTypeInfo => {
-  let genericArgs = undefined
-  let wtypeName = undefined
-  if (type instanceof PType) {
-    genericArgs = typeRegistry.isGeneric(type)
-      ? type.getGenericArgs().map(getGenericTypeInfo)
-      : type.wtype && Object.hasOwn(type.wtype, 'types')
-        ? (type.wtype as DeliberateAny).types.map(getGenericTypeInfo)
-        : undefined
-    wtypeName = type.wtype?.name
-  } else if (type) {
-    genericArgs = Object.hasOwn(type, 'types') ? (type as DeliberateAny).types.map(getGenericTypeInfo) : undefined
-    wtypeName = type.name
+const getGenericTypeInfo = (type: PType): GenericTypeInfo => {
+  let genericArgs: GenericTypeInfo[] | Record<string, GenericTypeInfo> | undefined = typeRegistry.isGeneric(type)
+    ? type.getGenericArgs().map(getGenericTypeInfo)
+    : undefined
+
+  if (!genericArgs || !genericArgs.length) {
+    if (Object.hasOwn(type, 'items')) {
+      genericArgs = (type as DeliberateAny).items.map(getGenericTypeInfo)
+    } else if (Object.hasOwn(type, 'itemType')) {
+      genericArgs = [getGenericTypeInfo((type as DeliberateAny).itemType)]
+    } else if (Object.hasOwn(type, 'properties')) {
+      genericArgs = Object.fromEntries(
+        Object.entries((type as DeliberateAny).properties).map(([key, value]) => [key, getGenericTypeInfo(value as PType)]),
+      )
+    }
   }
-  const result: GenericTypeInfo = { name: type?.name ?? 'unknown', wtypeName: wtypeName }
-  if (genericArgs && genericArgs.length) {
+
+  const result: GenericTypeInfo = { name: type?.name ?? 'unknown' }
+  if (genericArgs && (genericArgs.length || Object.keys(genericArgs).length)) {
     result.genericArgs = genericArgs
   }
   return result

tests/artifacts/box-contract/contract.algo.ts

@@ -1,14 +1,17 @@
-import { arc4, assert, Box, bytes, Bytes, op, TransactionType, uint64, Uint64 } from '@algorandfoundation/algorand-typescript'
+import { arc4, assert, Box, Bytes, op, TransactionType, uint64, Uint64 } from '@algorandfoundation/algorand-typescript'
+
+// type X = [a: uint64, b: string, c: bytes]
+// type Y = { a: uint64; b: string; c: bytes }
+// type Z = { x: X; y: Y }
 
-type X = [a: uint64, b: string, c: bytes]
-type Y = { a: uint64; b: string; c: bytes }
-type Z = { x: X; y: Y }
 export class BoxContract extends arc4.Contract {
   oca = Box<arc4.OnCompleteAction>({ key: Bytes('oca') })
   txn = Box<TransactionType>({ key: Bytes('txn') })
-  a = Box<X>({ key: Bytes('a') })
-  b = Box<Y>({ key: Bytes('b') })
-  c = Box<Z>({ key: Bytes('c') })
+
+  // a = Box<X>({ key: Bytes('a') })
+  // b = Box<Y>({ key: Bytes('b') })
+  // c = Box<Z>({ key: Bytes('c') })
+  // d = Box<Z[]>({ key: Bytes('d') })
 
   @arc4.abimethod()
   public storeEnums(): void {