feat: add stub implementation of arc4EncodedLength

Author: boblat

src/impl/encoded-types.ts

@@ -29,6 +29,7 @@ import {
   ALGORAND_ADDRESS_BYTE_LENGTH,
   ALGORAND_CHECKSUM_BYTE_LENGTH,
   BITS_IN_BYTE,
+  UINT512_SIZE,
   UINT64_SIZE,
 } from '../constants'
 import { lazyContext } from '../context-helpers/internal-context'
@@ -441,7 +442,7 @@ export class StaticArrayImpl<TItem extends ARC4Encoded, TLength extends number>
     const childTypes = Array(arraySize).fill(genericArgs.elementType)
     let i = 0
     let size = 0
-    if (genericArgs.elementType.name === 'Bool') {
+    if (['Bool', 'boolean'].includes(genericArgs.elementType.name)) {
       while (i < childTypes.length) {
         const after = findBoolTypes(childTypes, i, 1)
         const boolNum = after + 1
@@ -716,7 +717,7 @@ export class TupleImpl<TTuple extends [ARC4Encoded, ...ARC4Encoded[]]> extends T
 
     while (i < genericArgs.length) {
       const childType = genericArgs[i]
-      if (childType.name === 'Bool') {
+      if (['Bool', 'boolean'].includes(childType.name)) {
         const after = findBoolTypes(genericArgs, i, 1)
         const boolNum = after + 1
         size += Math.floor(boolNum / BITS_IN_BYTE)
@@ -821,6 +822,27 @@ export class StructImpl<T extends StructConstraint> extends (Struct<StructConstr
     const genericArgs = Object.values(t.genericArgs as Record<string, TypeInfo>)
     return `(${genericArgs.map(getArc4TypeName).join(',')})`
   }
+
+  static getMaxBytesLength(typeInfo: TypeInfo): number {
+    const genericArgs = Object.values(typeInfo.genericArgs as Record<string, TypeInfo>)
+    let i = 0
+    let size = 0
+
+    while (i < genericArgs.length) {
+      const childType = genericArgs[i]
+      if (['Bool', 'boolean'].includes(childType.name)) {
+        const after = findBoolTypes(genericArgs, i, 1)
+        const boolNum = after + 1
+        size += Math.floor(boolNum / BITS_IN_BYTE)
+        size += boolNum % BITS_IN_BYTE ? 1 : 0
+        i += after
+      } else {
+        size += getMaxLengthOfStaticContentType(childType)
+      }
+      i += 1
+    }
+    return size
+  }
 }
 
 export class DynamicBytesImpl extends DynamicBytes {
@@ -981,7 +1003,7 @@ const decode = (value: Uint8Array, childTypes: TypeInfo[]) => {
       dynamicSegments.push([dynamicIndex, -1])
       valuePartitions.push(new Uint8Array())
       arrayIndex += ABI_LENGTH_SIZE
-    } else if (childType.name === 'Bool') {
+    } else if (['Bool', 'boolean'].includes(childType.name)) {
       const before = findBoolTypes(childTypes, i, -1)
       let after = findBoolTypes(childTypes, i, 1)
 
@@ -1043,7 +1065,7 @@ const findBoolTypes = (values: TypeInfo[], index: number, delta: number): number
   const length = values.length
   while (true) {
     const curr = index + delta * until
-    if (values[curr].name === 'Bool') {
+    if (['Bool', 'boolean'].includes(values[curr].name)) {
       if ((curr != length - 1 && delta > 0) || (curr > 0 && delta < 0)) {
         until += 1
       } else {
@@ -1059,6 +1081,12 @@ const findBoolTypes = (values: TypeInfo[], index: number, delta: number): number
 
 const getMaxLengthOfStaticContentType = (type: TypeInfo): number => {
   switch (trimGenericTypeName(type.name)) {
+    case 'uint64':
+      return UINT64_SIZE / BITS_IN_BYTE
+    case 'biguint':
+      return UINT512_SIZE / BITS_IN_BYTE
+    case 'boolean':
+      return 1
     case 'Address':
       return AddressImpl.getMaxBytesLength(type)
     case 'Byte':
@@ -1073,6 +1101,8 @@ const getMaxLengthOfStaticContentType = (type: TypeInfo): number => {
       return StaticBytesImpl.getMaxBytesLength(type)
     case 'Tuple':
       return TupleImpl.getMaxBytesLength(type)
+    case 'Struct':
+      return StructImpl.getMaxBytesLength(type)
   }
   throw new CodeError(`unsupported type ${type.name}`)
 }
@@ -1324,3 +1354,8 @@ export const getArc4Encoded = (value: DeliberateAny): ARC4Encoded => {
 
   throw new CodeError(`Unsupported type for encoding: ${typeof value}`)
 }
+
+export const arc4EncodedLengthImpl = (typeInfoString: string): uint64 => {
+  const typeInfo = JSON.parse(typeInfoString)
+  return getMaxLengthOfStaticContentType(typeInfo)
+}

src/runtime-helpers.ts

@@ -12,7 +12,7 @@ import { nameOfType } from './util'
 export { attachAbiMetadata } from './abi-metadata'
 export { emitImpl } from './impl/emit'
 export * from './impl/encoded-types'
-export { decodeArc4Impl, encodeArc4Impl } from './impl/encoded-types'
+export { arc4EncodedLengthImpl, decodeArc4Impl, encodeArc4Impl } from './impl/encoded-types'
 
 export function switchableValue(x: unknown): bigint | string | boolean {
   if (typeof x === 'boolean') return x

src/test-transformer/visitors.ts

@@ -166,6 +166,8 @@ class ExpressionVisitor {
           const targetType = ptypes.ptypeToArc4EncodedType(type, this.helper.sourceLocation(node))
           const targetTypeInfo = getGenericTypeInfo(targetType)
           infoArg = targetTypeInfo
+        } else if (isCallingArc4EncodedLength(stubbedFunctionName)) {
+          infoArg = this.helper.resolveTypeParameters(updatedNode).map(getGenericTypeInfo)[0]
         }
 
         updatedNode = stubbedFunctionName
@@ -420,10 +422,11 @@ const tryGetStubbedFunctionName = (node: ts.CallExpression, helper: VisitorHelpe
     if (sourceFileName && !algotsModulePaths.some((s) => sourceFileName.includes(s))) return undefined
   }
   const functionName = functionSymbol?.getName() ?? identityExpression.text
-  const stubbedFunctionNames = ['interpretAsArc4', 'decodeArc4', 'encodeArc4', 'emit', 'methodSelector']
+  const stubbedFunctionNames = ['interpretAsArc4', 'decodeArc4', 'encodeArc4', 'emit', 'methodSelector', 'arc4EncodedLength']
   return stubbedFunctionNames.includes(functionName) ? functionName : undefined
 }
 
 const isCallingDecodeArc4 = (functionName: string | undefined): boolean => ['decodeArc4', '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 ?? '')

tests/arc4/encode-decode-arc4.spec.ts

@@ -1,6 +1,17 @@
 import type { biguint, bytes, uint64 } from '@algorandfoundation/algorand-typescript'
 import { Bytes } from '@algorandfoundation/algorand-typescript'
-import { Bool, decodeArc4, DynamicBytes, encodeArc4, Str, Struct, Tuple, UintN } from '@algorandfoundation/algorand-typescript/arc4'
+import type { Address, StaticArray, StaticBytes, UFixedNxM, UintN64 } from '@algorandfoundation/algorand-typescript/arc4'
+import {
+  arc4EncodedLength,
+  Bool,
+  decodeArc4,
+  DynamicBytes,
+  encodeArc4,
+  Str,
+  Struct,
+  Tuple,
+  UintN,
+} from '@algorandfoundation/algorand-typescript/arc4'
 import { describe, expect, test } from 'vitest'
 import { MAX_UINT128 } from '../../src/constants'
 import type { StubBytesCompat } from '../../src/impl/primitives'
@@ -122,6 +133,27 @@ describe('encodeArc4', () => {
   })
 })
 
+class StaticStruct extends Struct<{
+  a: UintN64
+  b: StaticArray<Bool, 10>
+  c: Bool
+  d: StaticBytes<32>
+  e: Address
+  f: StaticArray<UFixedNxM<256, 16>, 10>
+}> {}
+describe('arc4EncodedLength', () => {
+  test('should return the correct length', () => {
+    expect(arc4EncodedLength<uint64>()).toEqual(8)
+    expect(arc4EncodedLength<biguint>()).toEqual(64)
+    expect(arc4EncodedLength<boolean>()).toEqual(1)
+    expect(arc4EncodedLength<UintN<512>>()).toEqual(64)
+    expect(arc4EncodedLength<[uint64, uint64, boolean]>()).toEqual(17)
+    expect(arc4EncodedLength<[uint64, uint64, boolean, boolean]>()).toEqual(17)
+    expect(arc4EncodedLength<Tuple<[StaticArray<Bool, 10>, Bool]>>()).toEqual(3)
+    expect(arc4EncodedLength<StaticStruct>()).toEqual(395)
+  })
+})
+
 const compareNativeValues = (a: DeliberateAny, b: DeliberateAny) => {
   if (Array.isArray(a)) {
     for (let i = 0; i < a.length; i++) {

tests/arc4/tuple.spec.ts

@@ -26,6 +26,29 @@ const otherAbiString = new Str('hello')
 const otherAbiUint8 = new UintN<8>(42)
 
 const testData = [
+  {
+    abiTypeString: '(bool[10],bool,bool)',
+    nativeValues() {
+      return [
+        [nativeBool, nativeBool, nativeBool, nativeBool, nativeBool, nativeBool, nativeBool, nativeBool, nativeBool, nativeBool],
+        nativeBool,
+        nativeBool,
+      ]
+    },
+    abiValues() {
+      return [
+        new StaticArray(abiBool, abiBool, abiBool, abiBool, abiBool, abiBool, abiBool, abiBool, abiBool, abiBool),
+        abiBool,
+        abiBool,
+      ] as readonly [StaticArray<Bool, 10>, Bool, Bool]
+    },
+    tuple() {
+      return new Tuple<[StaticArray<Bool, 10>, Bool, Bool]>(...this.abiValues())
+    },
+    create(value: StubBytesCompat) {
+      return interpretAsArc4<Tuple<[StaticArray<Bool, 10>, Bool, Bool]>>(asBytes(value))
+    },
+  },
   {
     abiTypeString: '(uint8,bool,bool,address)',
     nativeValues() {