feat: implement stubs for encode/decode native arrays

boblat · boblat · commit 51d68f6e60dc · 2025-04-15T15:06:05.000+08:00
diff --git a/src/encoders.ts b/src/encoders.ts
@@ -85,7 +85,7 @@ export const toBytes = (val: unknown): bytes => {
     return val.bytes
   }
   if (Array.isArray(val) || typeof val === 'object') {
-    return encodeArc4Impl('', val)
+    return encodeArc4Impl(undefined, val)
   }
   throw new InternalError(`Invalid type for bytes: ${nameOfType(val)}`)
 }
diff --git a/src/impl/encoded-types.ts b/src/impl/encoded-types.ts
@@ -48,6 +48,7 @@ import {
   conactUint8Arrays,
   uint8ArrayToNumber,
 } from '../util'
+import { BytesBackedCls, Uint64BackedCls } from './base'
 import type { StubBytesCompat } from './primitives'
 import { AlgoTsPrimitiveCls, arrayUtil, BigUintCls, Bytes, BytesCls, getUint8Array, isBytes, Uint64Cls } from './primitives'
 import { Account, AccountCls, ApplicationCls, AssetCls } from './reference'
@@ -1297,31 +1298,49 @@ export const getArc4TypeName = (typeInfo: TypeInfo): string | undefined => {
   return undefined
 }
 
-export function decodeArc4Impl<T>(sourceTypeInfoString: string, bytes: StubBytesCompat, prefix: 'none' | 'log' = 'none'): T {
+export function decodeArc4Impl<T>(
+  sourceTypeInfoString: string,
+  targetTypeInfoString: string,
+  bytes: StubBytesCompat,
+  prefix: 'none' | 'log' = 'none',
+): T {
   const sourceTypeInfo = JSON.parse(sourceTypeInfoString)
+  const targetTypeInfo = JSON.parse(targetTypeInfoString)
   const encoder = getArc4Encoder(sourceTypeInfo)
-  const source = encoder(bytes, sourceTypeInfo, prefix)
-  return getNativeValue(source) as T
+  const source = encoder(bytes, sourceTypeInfo, prefix) as { typeInfo: TypeInfo }
+  return getNativeValue(source, targetTypeInfo) as T
 }
 
-export function encodeArc4Impl<T>(_targetTypeInfoString: string | undefined, source: T): bytes {
-  const arc4Encoded = getArc4Encoded(source)
+export function encodeArc4Impl<T>(sourceTypeInfoString: string | undefined, source: T): bytes {
+  const arc4Encoded = getArc4Encoded(source, sourceTypeInfoString)
   return arc4Encoded.bytes
 }
 
-const getNativeValue = (value: DeliberateAny): DeliberateAny => {
+const getNativeValue = (value: DeliberateAny, targetTypeInfo: TypeInfo | undefined): DeliberateAny => {
+  if (value.typeInfo && value.typeInfo.name === targetTypeInfo?.name) {
+    return value
+  }
   const native = (value as DeliberateAny).native
   if (Array.isArray(native)) {
-    return native.map((item) => getNativeValue(item))
+    return native.map((item) => getNativeValue(item, (targetTypeInfo?.genericArgs as { elementType: TypeInfo })?.elementType))
   } else if (native instanceof AlgoTsPrimitiveCls) {
     return native
+  } else if (native instanceof BytesBackedCls) {
+    return native.bytes
+  } else if (native instanceof Uint64BackedCls) {
+    return native.uint64
   } else if (typeof native === 'object') {
-    return Object.fromEntries(Object.entries(native).map(([key, value]) => [key, getNativeValue(value)]))
+    return Object.fromEntries(
+      Object.entries(native).map(([key, value], index) => [
+        key,
+        getNativeValue(value, (targetTypeInfo?.genericArgs as TypeInfo[])?.[index]),
+      ]),
+    )
   }
   return native
 }
 
-export const getArc4Encoded = (value: DeliberateAny): ARC4Encoded => {
+export const getArc4Encoded = (value: DeliberateAny, sourceTypeInfoString?: string): ARC4Encoded => {
   if (value instanceof ARC4Encoded) {
     return value
   }
@@ -1362,9 +1381,15 @@ export const getArc4Encoded = (value: DeliberateAny): ARC4Encoded => {
     const result: ARC4Encoded[] = value.reduce((acc: ARC4Encoded[], cur: DeliberateAny) => {
       return acc.concat(getArc4Encoded(cur))
     }, [])
+    const sourceTypeInfo = sourceTypeInfoString ? JSON.parse(sourceTypeInfoString) : undefined
     const genericArgs: TypeInfo[] = result.map((x) => (x as DeliberateAny).typeInfo)
-    const typeInfo = { name: `Tuple<[${genericArgs.map((x) => x.name).join(',')}]>`, genericArgs }
-    return new TupleImpl(typeInfo, ...(result as [ARC4Encoded, ...ARC4Encoded[]]))
+    if (sourceTypeInfo?.name?.startsWith('Array')) {
+      const typeInfo = { name: `DynamicArray<${genericArgs[0].name}>`, genericArgs: { elementType: genericArgs[0] } }
+      return new DynamicArrayImpl(typeInfo, ...(result as [ARC4Encoded, ...ARC4Encoded[]]))
+    } else {
+      const typeInfo = { name: `Tuple<[${genericArgs.map((x) => x.name).join(',')}]>`, genericArgs }
+      return new TupleImpl(typeInfo, ...(result as [ARC4Encoded, ...ARC4Encoded[]]))
+    }
   }
   if (typeof value === 'object') {
     const result = Object.values(value).reduce((acc: ARC4Encoded[], cur: DeliberateAny) => {
diff --git a/src/test-transformer/node-factory.ts b/src/test-transformer/node-factory.ts
@@ -94,8 +94,10 @@ export const nodeFactory = {
     )
   },
 
-  callStubbedFunction(functionName: string, node: ts.CallExpression, typeInfo?: TypeInfo) {
-    const typeInfoArg = typeInfo ? factory.createStringLiteral(JSON.stringify(typeInfo)) : undefined
+  callStubbedFunction(functionName: string, node: ts.CallExpression, typeInfo?: TypeInfo | TypeInfo[]) {
+    const typeInfoArgs = typeInfo
+      ? (Array.isArray(typeInfo) ? typeInfo : [typeInfo]).map((t) => factory.createStringLiteral(JSON.stringify(t)))
+      : undefined
     const updatedPropertyAccessExpression = factory.createPropertyAccessExpression(
       factory.createIdentifier('runtimeHelpers'),
       `${functionName}Impl`,
@@ -104,7 +106,7 @@ export const nodeFactory = {
     return factory.createCallExpression(
       updatedPropertyAccessExpression,
       node.typeArguments,
-      [typeInfoArg, ...(node.arguments ?? [])].filter((arg) => !!arg),
+      [...(typeInfoArgs ?? []), ...(node.arguments ?? [])].filter((arg) => !!arg),
     )
   },
 
diff --git a/src/test-transformer/visitors.ts b/src/test-transformer/visitors.ts
@@ -159,13 +159,16 @@ class ExpressionVisitor {
       if (ts.isCallExpression(updatedNode)) {
         const stubbedFunctionName = this.stubbedFunctionName ?? tryGetStubbedFunctionName(updatedNode, this.helper)
         this.stubbedFunctionName = undefined
-        let infoArg = info
+        let infoArg: TypeInfo | TypeInfo[] | undefined = info
         if (isCallingEmit(stubbedFunctionName)) {
           infoArg = this.helper.resolveTypeParameters(updatedNode).map(getGenericTypeInfo)[0]
         } else if (isCallingDecodeArc4(stubbedFunctionName)) {
-          const targetType = ptypes.ptypeToArc4EncodedType(type, this.helper.sourceLocation(node))
-          const targetTypeInfo = getGenericTypeInfo(targetType)
-          infoArg = targetTypeInfo
+          const sourceType = ptypes.ptypeToArc4EncodedType(type, this.helper.sourceLocation(node))
+          const sourceTypeInfo = getGenericTypeInfo(sourceType)
+          const targetTypeInfo = getGenericTypeInfo(type)
+          infoArg = [sourceTypeInfo, targetTypeInfo]
+        } else if (isCallingEncodeArc4(stubbedFunctionName)) {
+          infoArg = this.helper.resolveTypeParameters(updatedNode).map(getGenericTypeInfo)[0]
         } else if (isCallingArc4EncodedLength(stubbedFunctionName)) {
           infoArg = this.helper.resolveTypeParameters(updatedNode).map(getGenericTypeInfo)[0]
         }
@@ -384,7 +387,7 @@ const getGenericTypeInfo = (type: ptypes.PType): TypeInfo => {
   } else if (type instanceof ptypes.BoxMapPType) {
     genericArgs.push(getGenericTypeInfo(type.keyType))
     genericArgs.push(getGenericTypeInfo(type.contentType))
-  } else if (instanceOfAny(type, ptypes.StaticArrayType, ptypes.DynamicArrayType)) {
+  } else if (instanceOfAny(type, ptypes.StaticArrayType, ptypes.DynamicArrayType, ptypes.ArrayPType)) {
     const entries = []
     entries.push(['elementType', getGenericTypeInfo(type.elementType)])
     if (instanceOfAny(type, ptypes.StaticArrayType)) {
@@ -428,7 +431,8 @@ const tryGetStubbedFunctionName = (node: ts.CallExpression, helper: VisitorHelpe
   return stubbedFunctionNames.includes(functionName) ? functionName : undefined
 }
 
-const isCallingDecodeArc4 = (functionName: string | undefined): boolean => ['decodeArc4', 'encodeArc4'].includes(functionName ?? '')
+const isCallingDecodeArc4 = (functionName: string | undefined): boolean => ['decodeArc4'].includes(functionName ?? '')
+const isCallingEncodeArc4 = (functionName: string | undefined): boolean => ['encodeArc4'].includes(functionName ?? '')
 const isCallingArc4EncodedLength = (functionName: string | undefined): boolean => 'arc4EncodedLength' === (functionName ?? '')
 const isCallingEmit = (functionName: string | undefined): boolean => 'emit' === (functionName ?? '')
 const isCallingMethodSelector = (functionName: string | undefined): boolean => 'methodSelector' === (functionName ?? '')
diff --git a/tests/arc4/encode-decode-arc4.spec.ts b/tests/arc4/encode-decode-arc4.spec.ts
@@ -1,17 +1,23 @@
 import type { biguint, bytes, uint64 } from '@algorandfoundation/algorand-typescript'
 import { Bytes } from '@algorandfoundation/algorand-typescript'
-import type { Address, StaticArray, StaticBytes, UFixedNxM, UintN64 } from '@algorandfoundation/algorand-typescript/arc4'
+import type { StaticBytes, UFixedNxM } from '@algorandfoundation/algorand-typescript/arc4'
 import {
+  Address,
   arc4EncodedLength,
   Bool,
   decodeArc4,
+  DynamicArray,
   DynamicBytes,
   encodeArc4,
+  StaticArray,
   Str,
   Struct,
   Tuple,
   UintN,
+  UintN64,
 } from '@algorandfoundation/algorand-typescript/arc4'
+import { itob } from '@algorandfoundation/algorand-typescript/op'
+import { encodingUtil } from '@algorandfoundation/puya-ts'
 import { describe, expect, test } from 'vitest'
 import { MAX_UINT128 } from '../../src/constants'
 import type { StubBytesCompat } from '../../src/impl/primitives'
@@ -30,6 +36,7 @@ const abiUint512 = new UintN<512>(MAX_UINT128)
 const abiBool = new Bool(true)
 const abiBytes = new DynamicBytes(Bytes('hello'))
 
+type TestObj = { a: UintN64; b: DynamicBytes }
 class Swapped1 extends Struct<{
   b: UintN<64>
   c: Bool
@@ -40,14 +47,17 @@ class Swapped1 extends Struct<{
 const testData = [
   {
     nativeValues() {
-      return [nativeNumber, nativeNumber, nativeBigInt, nativeBytes]
+      return [nativeNumber, nativeNumber, nativeBigInt, nativeBytes] as readonly [uint64, uint64, biguint, bytes]
     },
     abiValues() {
       return [abiUint64, abiUint64, abiUint512, abiBytes] as readonly [UintN<64>, UintN<64>, UintN<512>, DynamicBytes]
     },
     arc4Value() {
       return new Tuple<[UintN<64>, UintN<64>, UintN<512>, DynamicBytes]>(abiUint64, abiUint64, abiUint512, abiBytes)
     },
+    encode() {
+      return encodeArc4(this.nativeValues())
+    },
     decode(value: StubBytesCompat) {
       return decodeArc4<[uint64, uint64, biguint, bytes]>(asBytes(value))
     },
@@ -58,6 +68,19 @@ const testData = [
         [nativeBool, [nativeString, nativeBool]],
         [nativeNumber, nativeNumber],
         [nativeBigInt, nativeBytes, { b: nativeNumber, c: nativeBool, d: nativeString, a: [nativeNumber, nativeBool, nativeBool] }],
+      ] as readonly [
+        [boolean, [string, boolean]],
+        [uint64, uint64],
+        [
+          biguint,
+          bytes,
+          {
+            b: uint64
+            c: boolean
+            d: string
+            a: [uint64, boolean, boolean]
+          },
+        ],
       ]
     },
     abiValues() {
@@ -76,6 +99,9 @@ const testData = [
         ...this.abiValues(),
       )
     },
+    encode() {
+      return encodeArc4(this.nativeValues())
+    },
     decode(value: StubBytesCompat) {
       return decodeArc4<
         [
@@ -105,6 +131,9 @@ const testData = [
     arc4Value() {
       return new Swapped1(this.abiValues())
     },
+    encode() {
+      return encodeArc4(this.nativeValues())
+    },
     decode(value: StubBytesCompat) {
       return decodeArc4<{ b: uint64; c: boolean; d: string; a: [uint64, boolean, boolean] }>(asBytes(value))
     },
@@ -120,17 +149,67 @@ describe('decodeArc4', () => {
 
     compareNativeValues(result, nativeValues)
   })
+  test('should be able to decode arrays', () => {
+    const a = 234234
+    const aBytes = asBytes(encodingUtil.bigIntToUint8Array(234234n, 8))
+    const b = true
+    const bBytes = asBytes(encodingUtil.bigIntToUint8Array(128n, 1))
+    const c = 340943934n
+    const cBytes = asBytes(encodingUtil.bigIntToUint8Array(340943934n, 512 / 8))
+    const d = 'hello world'
+    const dBytes = asBytes(
+      new Uint8Array([
+        ...encodingUtil.bigIntToUint8Array(BigInt('hello world'.length), 2),
+        ...encodingUtil.utf8ToUint8Array('hello world'),
+      ]),
+    )
+    const e = { a: 50n, b: new Uint8Array([1, 2, 3, 4, 5]) }
+    const eBytes = asBytes(new Uint8Array([...encodingUtil.bigIntToUint8Array(50n, 8), 0, 10, 0, 5, 1, 2, 3, 4, 5]))
+    const f = new Address(Bytes.fromHex(`${'00'.repeat(31)}ff`))
+    const fBytes = Bytes.fromHex(`${'00'.repeat(31)}ff`)
+    expect(decodeArc4<uint64>(aBytes)).toEqual(a)
+    expect(decodeArc4<boolean>(bBytes)).toEqual(b)
+    expect(decodeArc4<biguint>(cBytes)).toEqual(c)
+    expect(decodeArc4<string>(dBytes)).toEqual(d)
+    expect(decodeArc4<TestObj>(eBytes)).toEqual(e)
+
+    const lenPrefix = itob(1).slice(6, 8)
+    const offsetHeader = itob(2).slice(6, 8)
+    expect(decodeArc4<uint64[]>(lenPrefix.concat(aBytes))).toEqual([a])
+    expect(decodeArc4<boolean[]>(lenPrefix.concat(bBytes))).toEqual([b])
+    expect(decodeArc4<biguint[]>(lenPrefix.concat(cBytes))).toEqual([c])
+    expect(decodeArc4<string[]>(Bytes`${lenPrefix}${offsetHeader}${dBytes}`)).toEqual([d])
+    expect(decodeArc4<TestObj[]>(Bytes`${lenPrefix}${offsetHeader}${eBytes}`)).toEqual([e])
+    expect(JSON.stringify(decodeArc4<Address[]>(Bytes`${lenPrefix}${fBytes}`))).toEqual(JSON.stringify([f]))
+  })
 })
 
 describe('encodeArc4', () => {
   test.each(testData)('should encode native values', (data) => {
-    const nativeValues = data.nativeValues()
     const arc4Value = data.arc4Value()
 
-    const result = encodeArc4(nativeValues)
+    const result = data.encode()
 
     expect(result).toEqual(arc4Value.bytes)
   })
+  test('should be able to encode arrays', () => {
+    const address = new Address(Bytes.fromHex(`${'00'.repeat(31)}ff`))
+    expect(encodeArc4(address)).toEqual(address.bytes)
+
+    expect(encodeArc4([nativeNumber])).toEqual(new StaticArray(new UintN64(nativeNumber)).bytes)
+    expect(encodeArc4([nativeBool])).toEqual(new StaticArray(new Bool(nativeBool)).bytes)
+    expect(encodeArc4([nativeBigInt])).toEqual(new StaticArray(new UintN<512>(nativeBigInt)).bytes)
+    expect(encodeArc4([nativeBytes])).toEqual(new StaticArray(new DynamicBytes(nativeBytes)).bytes)
+    expect(encodeArc4([nativeString])).toEqual(new StaticArray(new Str(nativeString)).bytes)
+    expect(encodeArc4([address])).toEqual(new StaticArray(address).bytes)
+
+    expect(encodeArc4<uint64[]>([nativeNumber])).toEqual(new DynamicArray(new UintN64(nativeNumber)).bytes)
+    expect(encodeArc4<boolean[]>([nativeBool])).toEqual(new DynamicArray(new Bool(nativeBool)).bytes)
+    expect(encodeArc4<biguint[]>([nativeBigInt])).toEqual(new DynamicArray(new UintN<512>(nativeBigInt)).bytes)
+    expect(encodeArc4<bytes[]>([nativeBytes])).toEqual(new DynamicArray(new DynamicBytes(nativeBytes)).bytes)
+    expect(encodeArc4<string[]>([nativeString])).toEqual(new DynamicArray(new Str(nativeString)).bytes)
+    expect(encodeArc4<Address[]>([address])).toEqual(new DynamicArray(address).bytes)
+  })
 })
 
 class StaticStruct extends Struct<{

Original file line number	Diff line number	Diff line change
`@@ -85,7 +85,7 @@ export const toBytes = (val: unknown): bytes => {`
`85`	`85`	`return val.bytes`
`86`	`86`	`}`
`87`	`87`	`if (Array.isArray(val) \|\| typeof val === 'object') {`
`88`		`- return encodeArc4Impl('', val)`
	`88`	`+ return encodeArc4Impl(undefined, val)`
`89`	`89`	`}`
`90`	`90`	throw new InternalError(`Invalid type for bytes: ${nameOfType(val)}`)
`91`	`91`	`}`