refactor: add tests dependent upon arc4 types

Author: boblat

src/impl/app-global.ts

@@ -1,6 +1,6 @@
 import { Application, Bytes, bytes, internal, Uint64, uint64 } from '@algorandfoundation/algorand-typescript'
 import { lazyContext } from '../context-helpers/internal-context'
-import { asBytes } from '../util'
+import { asBytes, toBytes } from '../util'
 import { getApp } from './app-params'
 
 export const AppGlobal: internal.opTypes.AppGlobalType = {
@@ -22,7 +22,7 @@ export const AppGlobal: internal.opTypes.AppGlobalType = {
     if (!exists) {
       return [Bytes(), false]
     }
-    return [state!.value as bytes, exists]
+    return [toBytes(state!.value), exists]
   },
   getExUint64(a: Application | internal.primitives.StubUint64Compat, b: internal.primitives.StubBytesCompat): readonly [uint64, boolean] {
     const app = getApp(a)

src/impl/app-local.ts

@@ -1,6 +1,6 @@
 import { Account, Application, Bytes, bytes, internal, Uint64, uint64 } from '@algorandfoundation/algorand-typescript'
 import { lazyContext } from '../context-helpers/internal-context'
-import { asBytes } from '../util'
+import { asBytes, toBytes } from '../util'
 import { getAccount } from './acct-params'
 import { getApp } from './app-params'
 
@@ -32,7 +32,7 @@ export const AppLocal: internal.opTypes.AppLocalType = {
     if (!exists) {
       return [Bytes(), false]
     }
-    return [state!.value as bytes, exists]
+    return [toBytes(state!.value), exists]
   },
   getExUint64: function (
     a: Account | internal.primitives.StubUint64Compat,

src/set-up.ts

@@ -1,4 +1,5 @@
 import { internal } from '@algorandfoundation/algorand-typescript'
+import { Address } from '@algorandfoundation/algorand-typescript/arc4'
 import { encodingUtil } from '@algorandfoundation/puya-ts'
 import { AccountCls } from './impl/account'
 
@@ -77,6 +78,33 @@ function addEqualityTesters(expectObj: ExpectObj) {
       // Defer to other testers
       return undefined
     },
+    function AddressIsAccountStr(this: TesterContext, subject, test, customTesters): boolean | undefined {
+      if (subject instanceof Address) {
+        const testValue = typeof test === 'string' ? encodingUtil.base32ToUint8Array(test).slice(0, 32) : undefined
+        if (testValue !== undefined) return this.equals(subject.native.bytes, testValue, customTesters)
+        return undefined
+      }
+      // Defer to other testers
+      return undefined
+    },
+    function AddressIsAccountBytes(this: TesterContext, subject, test, customTesters): boolean | undefined {
+      if (subject instanceof Address) {
+        const testValue = test instanceof internal.primitives.BytesCls ? test.asUint8Array().slice(0, 32) : undefined
+        if (testValue !== undefined) return this.equals(subject.native.bytes, testValue, customTesters)
+        return undefined
+      }
+      // Defer to other testers
+      return undefined
+    },
+    function AddressIsAccount(this: TesterContext, subject, test, customTesters): boolean | undefined {
+      if (subject instanceof Address) {
+        const testValue = test instanceof AccountCls ? test.bytes : undefined
+        if (testValue !== undefined) return this.equals(subject.native.bytes, testValue, customTesters)
+        return undefined
+      }
+      // Defer to other testers
+      return undefined
+    },
   ])
 }
 

src/subcontexts/contract-context.ts

@@ -18,7 +18,7 @@ import {
 } from '../impl/transactions'
 import { getGenericTypeInfo } from '../runtime-helpers'
 import { DeliberateAny, IConstructor } from '../typescript-helpers'
-import { asUint64Cls } from '../util'
+import { toBytes } from '../util'
 
 type StateTotals = Pick<Application, 'globalNumBytes' | 'globalNumUint' | 'localNumBytes' | 'localNumUint'>
 
@@ -76,18 +76,17 @@ const extractArraysFromArgs = (app: Application, args: DeliberateAny[]) => {
   const assets: Asset[] = []
   const appArgs: bytes[] = []
 
-  // TODO: replace `asUint64Cls(accounts.length).toBytes().asAlgoTs()` with `arc4.Uint8(account.length).toBytes().asAlgoTs()`
   for (const arg of args) {
     if (isTransaction(arg)) {
       transactions.push(arg)
     } else if (arg instanceof AccountCls) {
-      appArgs.push(asUint64Cls(accounts.length).toBytes().asAlgoTs())
+      appArgs.push(toBytes(accounts.length))
       accounts.push(arg as Account)
     } else if (arg instanceof ApplicationCls) {
-      appArgs.push(asUint64Cls(apps.length).toBytes().asAlgoTs())
+      appArgs.push(toBytes(apps.length))
       apps.push(arg as Application)
     } else if (arg instanceof AssetCls) {
-      appArgs.push(asUint64Cls(assets.length).toBytes().asAlgoTs())
+      appArgs.push(toBytes(assets.length))
       assets.push(arg as Asset)
     }
   }

src/test-execution-context.ts

@@ -28,13 +28,13 @@ export class TestExecutionContext implements internal.ExecutionContext {
   #valueGenerator: ValueGenerator
   #defaultSender: Account
 
-  constructor() {
+  constructor(defaultSenderAddress?: bytes) {
     internal.ctxMgr.instance = this
     this.#contractContext = new ContractContext()
     this.#ledgerContext = new LedgerContext()
     this.#txnContext = new TransactionContext()
     this.#valueGenerator = new ValueGenerator()
-    this.#defaultSender = Account(Bytes.fromBase32(algosdk.generateAccount().addr))
+    this.#defaultSender = Account(defaultSenderAddress ?? Bytes.fromBase32(algosdk.generateAccount().addr))
   }
 
   account(address?: bytes): Account {

src/util.ts

@@ -1,4 +1,5 @@
 import { Bytes, bytes, internal } from '@algorandfoundation/algorand-typescript'
+import { ARC4Encoded } from '@algorandfoundation/algorand-typescript/arc4'
 import { randomBytes } from 'crypto'
 import { BITS_IN_BYTE, MAX_BYTES_SIZE, MAX_UINT512, MAX_UINT8, UINT512_SIZE } from './constants'
 import { BytesBackedCls, Uint64BackedCls } from './impl/base'
@@ -45,7 +46,6 @@ export const asBytes = (val: internal.primitives.StubBytesCompat | Uint8Array) =
 
 export const asUint8Array = (val: internal.primitives.StubBytesCompat | Uint8Array) => asBytesCls(val).asUint8Array()
 
-//TODO: handle arc4 types, bytes backed types
 export const toBytes = (val: unknown): bytes => {
   const uint64Val = asMaybeUint64Cls(val)
   if (uint64Val !== undefined) {
@@ -66,17 +66,13 @@ export const toBytes = (val: unknown): bytes => {
     return asUint64Cls(val.uint64).toBytes().asAlgoTs()
   }
   if (Array.isArray(val)) {
-    // This hack handles tuples/arrays of uint64 only
     return val.reduce((acc: bytes, cur: unknown) => {
-      const uint64Val = asMaybeUint64Cls(cur)
-      if (!uint64Val) {
-        // TODO: support ABI tuple encoding
-        // internal.errors.internalError(`ABI tuple encoding not supported: ${nameOfType(val)}`)
-        return acc.concat(Bytes())
-      }
       return acc.concat(toBytes(cur))
     }, Bytes())
   }
+  if (val instanceof ARC4Encoded) {
+    return val.bytes
+  }
   internal.errors.internalError(`Invalid type for bytes: ${nameOfType(val)}`)
 }
 

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

@@ -1,31 +1,21 @@
-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 }
+import { arc4, assert, Box, Bytes, op, TransactionType } from '@algorandfoundation/algorand-typescript'
+import { Tuple, UintN64 } from '@algorandfoundation/algorand-typescript/arc4'
 
 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') })
-  // d = Box<Z[]>({ key: Bytes('d') })
-
   @arc4.abimethod()
   public storeEnums(): void {
     this.oca.value = arc4.OnCompleteAction.OptIn
     this.txn.value = TransactionType.ApplicationCall
   }
 
   @arc4.abimethod()
-  public read_enums(): readonly [uint64, uint64] {
+  public read_enums(): Tuple<[UintN64, UintN64]> {
     assert(op.Box.get(Bytes('oca'))[0] === op.itob(this.oca.value))
     assert(op.Box.get(Bytes('txn'))[0] === op.itob(this.txn.value))
 
-    return [Uint64(this.oca.value), Uint64(this.txn.value)]
-    // TODO: use arc4 types when available
-    // return arc4.Tuple((arc4.UInt64(this.oca.value), arc4.UInt64(this.txn.value)))
+    return new Tuple(new UintN64(this.oca.value), new UintN64(this.txn.value))
   }
 }

tests/artifacts/crypto-ops/contract.algo.ts

@@ -1,4 +1,5 @@
 import { arc4, bytes, Ecdsa, ensureBudget, op, OpUpFeeSource, uint64, VrfVerify } from '@algorandfoundation/algorand-typescript'
+import { Bool } from '@algorandfoundation/algorand-typescript/arc4'
 
 export class CryptoOpsContract extends arc4.Contract {
   @arc4.abimethod()
@@ -29,20 +30,18 @@ export class CryptoOpsContract extends arc4.Contract {
     return result
   }
 
-  // TODO: return arc4.Bool to match python version when arc4 types are available
   @arc4.abimethod()
-  public verify_ed25519verify(a: bytes, b: bytes, c: bytes): boolean {
+  public verify_ed25519verify(a: bytes, b: bytes, c: bytes): Bool {
     ensureBudget(1900, OpUpFeeSource.GroupCredit)
     const result = op.ed25519verify(a, b, c)
-    return result
+    return new Bool(result)
   }
 
-  // TODO: return arc4.Bool to match python version when arc4 types are available
   @arc4.abimethod()
-  public verify_ed25519verify_bare(a: bytes, b: bytes, c: bytes): boolean {
+  public verify_ed25519verify_bare(a: bytes, b: bytes, c: bytes): Bool {
     ensureBudget(1900, OpUpFeeSource.GroupCredit)
     const result = op.ed25519verifyBare(a, b, c)
-    return result
+    return new Bool(result)
   }
 
   @arc4.abimethod()

tests/artifacts/primitive-ops/contract.algo.ts

@@ -1,4 +1,18 @@
-import { arc4, biguint, BigUint, Bytes, bytes, op, uint64 } from '@algorandfoundation/algorand-typescript'
+import { arc4, biguint, BigUint, Bytes, bytes, log, op, uint64 } from '@algorandfoundation/algorand-typescript'
+import {
+  Bool,
+  DynamicArray,
+  interpretAsArc4,
+  StaticArray,
+  Str,
+  Tuple,
+  UFixedNxM,
+  UintN,
+  UintN16,
+  UintN32,
+  UintN64,
+  UintN8,
+} from '@algorandfoundation/algorand-typescript/arc4'
 
 export class PrimitiveOpsContract extends arc4.Contract {
   @arc4.abimethod()
@@ -390,27 +404,26 @@ export class PrimitiveOpsContract extends arc4.Contract {
     return result
   }
 
-  // TODO: uncomment when arc4 types are available
-  // @arc4.abimethod
-  // public verify_log(  # noqa: PLR0913
-  //     self,
-  //     a: String,
-  //     b: uint64,
-  //     c: bytes,
-  //     d: bytes,
-  //     e: arc4.boolean,
-  //     f: arc4.String,
-  //     g: arc4.UIntN[typing.Literal[64]],
-  //     h: arc4.BigUIntN[typing.Literal[256]],
-  //     i: arc4.UFixedNxM[typing.Literal[32], typing.Literal[8]],
-  //     j: arc4.BigUFixedNxM[typing.Literal[256], typing.Literal[16]],
-  //     k: bytes,
-  //     m: bytes,
-  //     n: bytes,
-  // ) : None:
-  //     d_biguint = BigUint(d)
-  //     arc4_k = arc4.StaticArray[arc4.UInt8, typing.Literal[3]].from_bytes(k)
-  //     arc4_m = arc4.DynamicArray[arc4.UInt16].from_bytes(m)
-  //     arc4_n = arc4.Tuple[arc4.UInt32, arc4.uint64, arc4.String].from_bytes(n)
-  //     log(a, b, c, d_biguint, e, f, g, h, i, j, arc4_k, arc4_m, arc4_n, sep="-")
+  @arc4.abimethod()
+  public verify_log(
+    a: string,
+    b: uint64,
+    c: bytes,
+    d: bytes,
+    e: Bool,
+    f: Str,
+    g: UintN<64>,
+    h: UintN<256>,
+    i: UFixedNxM<32, 8>,
+    j: UFixedNxM<256, 16>,
+    k: bytes,
+    m: bytes,
+    n: bytes,
+  ) {
+    const d_biguint = BigUint(d)
+    const arc4_k = interpretAsArc4<StaticArray<UintN8, 3>>(k)
+    const arc4_m = interpretAsArc4<DynamicArray<UintN16>>(m)
+    const arc4_n = interpretAsArc4<Tuple<[UintN32, UintN64, Str]>>(n)
+    log(a, b, c, d_biguint, e, f, g, h, i, j, arc4_k, arc4_m, arc4_n)
+  }
 }