fix: ARC4 contracts should log the return value of an abi method, encoded as bytes and prefixed with a specific byte pattern detailed by arc4

Author: tristanmenzel

src/abi-metadata.ts

@@ -1,4 +1,4 @@
-import { Contract } from '@algorandfoundation/algorand-typescript'
+import { BaseContract, Contract } from '@algorandfoundation/algorand-typescript'
 import { AbiMethodConfig, BareMethodConfig, CreateOptions, OnCompleteActionStr } from '@algorandfoundation/algorand-typescript/arc4'
 import { DeliberateAny } from './typescript-helpers'
 
@@ -50,7 +50,7 @@ export const hasAbiMetadata = <T extends Contract>(contract: T): boolean => {
   )
 }
 
-export const getAbiMetadata = <T extends Contract>(contract: T, methodName: string): AbiMetadata => {
+export const getAbiMetadata = <T extends BaseContract>(contract: T, methodName: string): AbiMetadata => {
   const contractClass = contract.constructor as { new (): T }
   const s = Object.getOwnPropertySymbols(contractClass).find((s) => s.toString() === AbiMetaSymbol.toString())
   const metadatas: Record<string, AbiMetadata> = (

src/constants.ts

@@ -35,3 +35,5 @@ export const LOGIC_DATA_PREFIX = Bytes('ProgData')
 
 //number: minimum transaction fee
 export const MIN_TXN_FEE = 1000
+
+export const ABI_RETURN_VALUE_LOG_PREFIX = Bytes.fromHex('151F7C75')

src/decode-logs.ts

@@ -1,18 +1,18 @@
-import { internal } from '@algorandfoundation/algorand-typescript'
+import { bytes, op } from '@algorandfoundation/algorand-typescript'
 
 export type LogDecoding = 'i' | 's' | 'b'
 
 export type DecodedLog<T extends LogDecoding> = T extends 'i' ? bigint : T extends 's' ? string : Uint8Array
 export type DecodedLogs<T extends [...LogDecoding[]]> = {
   [Index in keyof T]: DecodedLog<T[Index]>
 } & { length: T['length'] }
-export function decodeLogs<const T extends [...LogDecoding[]]>(logs: Uint8Array[], decoding: T): DecodedLogs<T> {
+export function decodeLogs<const T extends [...LogDecoding[]]>(logs: bytes[], decoding: T): DecodedLogs<T> {
   return logs.map((log, i) => {
     switch (decoding[i]) {
       case 'i':
-        return internal.encodingUtil.uint8ArrayToBigInt(log)
+        return op.btoi(log)
       case 's':
-        return internal.encodingUtil.uint8ArrayToUtf8(log)
+        return log.toString()
       default:
         return log
     }

src/impl/transactions.ts

@@ -11,7 +11,7 @@ import {
   uint64,
   Uint64,
 } from '@algorandfoundation/algorand-typescript'
-import { MAX_ITEMS_IN_LOG } from '../constants'
+import { ABI_RETURN_VALUE_LOG_PREFIX, MAX_ITEMS_IN_LOG } from '../constants'
 import { lazyContext } from '../context-helpers/internal-context'
 import { Mutable, ObjectKeys } from '../typescript-helpers'
 import { asBytes, asMaybeBytesCls, asMaybeUint64Cls, asNumber, asUint64Cls, combineIntoMaxBytePages, getRandomBytes } from '../util'
@@ -334,6 +334,10 @@ export class ApplicationTransaction extends TransactionBase implements gtxn.Appl
     }
     this.#appLogs.push(asBytes(value))
   }
+  /* @internal */
+  logArc4ReturnValue(value: internal.primitives.StubBytesCompat): void {
+    this.appendLog(ABI_RETURN_VALUE_LOG_PREFIX.concat(asBytes(value)))
+  }
 }
 
 export type Transaction =

src/subcontexts/contract-context.ts

@@ -1,5 +1,5 @@
 import { Account, Application, Asset, BaseContract, Bytes, bytes, Contract, internal } from '@algorandfoundation/algorand-typescript'
-import { getAbiMetadata, hasAbiMetadata } from '../abi-metadata'
+import { getAbiMetadata } from '../abi-metadata'
 import { lazyContext } from '../context-helpers/internal-context'
 import { AccountCls } from '../impl/account'
 import { ApplicationCls } from '../impl/application'
@@ -96,11 +96,24 @@ function isTransaction(obj: unknown): obj is Transaction {
 
 export class ContractContext {
   create<T extends BaseContract>(type: IConstructor<T>, ...args: DeliberateAny[]): T {
-    const proxy = new Proxy(type, this.getContractProxyHandler<T>())
+    Object.getPrototypeOf(type)
+    const proxy = new Proxy(type, this.getContractProxyHandler<T>(this.isArc4(type)))
     return new proxy(...args)
   }
 
-  private getContractProxyHandler<T extends BaseContract>(): ProxyHandler<IConstructor<T>> {
+  private isArc4<T extends BaseContract>(type: IConstructor<T>): boolean {
+    const proto = Object.getPrototypeOf(type)
+    if (proto === BaseContract) {
+      return false
+    } else if (proto === Contract) {
+      return true
+    } else if (proto === Object) {
+      throw new Error('Cannot create a contract for class as it does not extend Contract or BaseContract')
+    }
+    return this.isArc4(proto)
+  }
+
+  private getContractProxyHandler<T extends BaseContract>(isArc4: boolean): ProxyHandler<IConstructor<T>> {
     const onConstructed = (instance: BaseContract) => {
       const states = extractStates(instance)
 
@@ -111,31 +124,35 @@ export class ContractContext {
     }
     return {
       construct(target, args) {
-        let isArc4 = false
         const instance = new Proxy(new target(...args), {
           get(target, prop, receiver) {
             const orig = Reflect.get(target, prop, receiver)
-            if (isArc4 || prop === 'approvalProgram' || prop === 'clearStateProgram') {
+            const isProgramMethod = prop === 'approvalProgram' || prop === 'clearStateProgram'
+            if (isArc4 || isProgramMethod) {
               return (...args: DeliberateAny[]): DeliberateAny => {
                 const app = lazyContext.ledger.getApplicationForContract(receiver)
                 const { transactions, ...appCallArgs } = extractArraysFromArgs(args)
-                const abiMetadata = getAbiMetadata(receiver, prop as string)
-                const txns = [
-                  ...(transactions ?? []),
-                  lazyContext.any.txn.applicationCall({
-                    appId: app,
-                    ...appCallArgs,
-                    onCompletion: (abiMetadata?.allowActions ?? [])[0],
-                  }),
-                ]
-                return lazyContext.txn.ensureScope(txns).execute(() => (orig as DeliberateAny).apply(target, args))
+                const abiMetadata = getAbiMetadata(target, prop as string)
+                const appTxn = lazyContext.any.txn.applicationCall({
+                  appId: app,
+                  ...appCallArgs,
+                  // TODO: This needs to be specifiable by the test code
+                  onCompletion: (abiMetadata?.allowActions ?? [])[0],
+                })
+                const txns = [...(transactions ?? []), appTxn]
+                return lazyContext.txn.ensureScope(txns).execute(() => {
+                  const returnValue = (orig as DeliberateAny).apply(target, args)
+                  if (isArc4) {
+                    appTxn.logArc4ReturnValue(returnValue)
+                  }
+                  return returnValue
+                })
               }
             }
             return orig
           },
         })
         onConstructed(instance)
-        isArc4 = hasAbiMetadata(instance as Contract)
 
         return instance
       },

src/subcontexts/transaction-context.ts

@@ -3,6 +3,16 @@ import algosdk from 'algosdk'
 import { lazyContext } from '../context-helpers/internal-context'
 import { DecodedLogs, decodeLogs, LogDecoding } from '../decode-logs'
 import { testInvariant } from '../errors'
+import {
+  ApplicationInnerTxn,
+  AssetConfigInnerTxn,
+  AssetFreezeInnerTxn,
+  AssetTransferInnerTxn,
+  createInnerTxn,
+  KeyRegistrationInnerTxn,
+  PaymentInnerTxn,
+} from '../impl/inner-transactions'
+import { InnerTxn, InnerTxnFields } from '../impl/itxn'
 import {
   AllTransactionFields,
   ApplicationTransaction,
@@ -14,16 +24,6 @@ import {
   Transaction,
 } from '../impl/transactions'
 import { asBigInt, asNumber, asUint64 } from '../util'
-import { InnerTxn, InnerTxnFields } from '../impl/itxn'
-import {
-  ApplicationInnerTxn,
-  AssetConfigInnerTxn,
-  AssetFreezeInnerTxn,
-  AssetTransferInnerTxn,
-  createInnerTxn,
-  KeyRegistrationInnerTxn,
-  PaymentInnerTxn,
-} from '../impl/inner-transactions'
 
 function ScopeGenerator(dispose: () => void) {
   function* internal() {
@@ -119,8 +119,8 @@ export class TransactionContext {
     } else {
       logs = lazyContext.getApplicationData(appId).appLogs
     }
-    const rawLogs = logs.map((l) => internal.primitives.toExternalValue(l))
-    return decodeLogs(rawLogs, decoding)
+
+    return decodeLogs(logs, decoding)
   }
 }