fix: ensure contract proxy has abimetadata;

fix: pass method name to deferAppCall;
fix: add routing condition check;
fix: capture state totals override from contract decorator

Author: boblat

examples/calculator/contract.spec.ts

@@ -1,4 +1,4 @@
-import { internal, op, Uint64 } from '@algorandfoundation/algorand-typescript'
+import { internal, Uint64 } from '@algorandfoundation/algorand-typescript'
 import { TestExecutionContext } from '@algorandfoundation/algorand-typescript-testing'
 import { afterEach, describe, expect, it } from 'vitest'
 import MyContract from './contract.algo'
@@ -31,7 +31,7 @@ describe('Calculator', () => {
         .createScope([
           ctx.any.txn.applicationCall({
             appId: application,
-            appArgs: [op.itob(Uint64(1)), op.itob(Uint64(2)), op.itob(Uint64(3))],
+            appArgs: [Uint64(1), Uint64(2), Uint64(3)],
           }),
         ])
         .execute(contract.approvalProgram)

src/abi-metadata.ts

@@ -14,6 +14,7 @@ export interface AbiMetadata {
   allowActions?: OnCompleteActionStr[]
 }
 const AbiMetaSymbol = Symbol('AbiMetadata')
+export const isContractProxy = Symbol('isContractProxy')
 export const attachAbiMetadata = (contract: { new (): Contract }, methodName: string, metadata: AbiMetadata): void => {
   const metadatas: Record<string, AbiMetadata> = (AbiMetaSymbol in contract ? contract[AbiMetaSymbol] : {}) as Record<string, AbiMetadata>
   metadatas[methodName] = metadata
@@ -26,12 +27,21 @@ export const attachAbiMetadata = (contract: { new (): Contract }, methodName: st
   }
 }
 
+export const copyAbiMetadatas = <T extends BaseContract>(sourceContract: T, targetContract: T): void => {
+  const metadatas = getContractAbiMetadata(sourceContract)
+  Object.defineProperty(targetContract, AbiMetaSymbol, {
+    value: metadatas,
+    writable: true,
+    enumerable: false,
+  })
+}
+
 export const captureMethodConfig = <T extends Contract>(
   contract: T,
   methodName: string,
   config?: AbiMethodConfig<T> | BareMethodConfig,
 ): void => {
-  const metadata = getAbiMetadata(contract, methodName)
+  const metadata = getContractMethodAbiMetadata(contract, methodName)
   metadata.onCreate = config?.onCreate ?? 'disallow'
   metadata.allowActions = ([] as OnCompleteActionStr[]).concat(config?.allowActions ?? 'NoOp')
 }
@@ -42,13 +52,20 @@ export const hasAbiMetadata = <T extends Contract>(contract: T): boolean => {
     Object.getOwnPropertySymbols(contractClass).some((s) => s.toString() === AbiMetaSymbol.toString()) || AbiMetaSymbol in contractClass
   )
 }
-
-export const getAbiMetadata = <T extends BaseContract>(contract: T, methodName: string): AbiMetadata => {
+export const getContractAbiMetadata = <T extends BaseContract>(contract: T): Record<string, AbiMetadata> => {
+  if ((contract as DeliberateAny)[isContractProxy]) {
+    return (contract as DeliberateAny)[AbiMetaSymbol] as Record<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> = (
     s ? (contractClass as DeliberateAny)[s] : AbiMetaSymbol in contractClass ? contractClass[AbiMetaSymbol] : {}
   ) as Record<string, AbiMetadata>
+  return metadatas
+}
+
+export const getContractMethodAbiMetadata = <T extends BaseContract>(contract: T, methodName: string): AbiMetadata => {
+  const metadatas = getContractAbiMetadata(contract)
   return metadatas[methodName]
 }
 

src/context-helpers/context-util.ts

@@ -0,0 +1,21 @@
+import { internal, uint64 } from '@algorandfoundation/algorand-typescript'
+import { AbiMetadata } from '../abi-metadata'
+import { ApplicationTransaction } from '../impl/transactions'
+import { lazyContext } from './internal-context'
+
+export const checkRoutingConditions = (appId: uint64, metadata: AbiMetadata) => {
+  const appData = lazyContext.getApplicationData(appId)
+  const isCreating = appData.isCreating
+  if (isCreating && metadata.onCreate === 'disallow') {
+    throw new internal.errors.CodeError('method can not be called while creating')
+  }
+  if (!isCreating && metadata.onCreate === 'require') {
+    throw new internal.errors.CodeError('method can only be called while creating')
+  }
+  const txn = lazyContext.activeGroup.activeTransaction
+  if (txn instanceof ApplicationTransaction && metadata.allowActions && !metadata.allowActions.includes(txn.onCompletion)) {
+    throw new internal.errors.CodeError(
+      `method can only be called with one of the following on_completion values: ${metadata.allowActions.join(', ')}`,
+    )
+  }
+}

src/context-helpers/internal-context.ts

@@ -1,4 +1,4 @@
-import { Account, internal } from '@algorandfoundation/algorand-typescript'
+import { Account, BaseContract, internal } from '@algorandfoundation/algorand-typescript'
 import { AccountData } from '../impl/account'
 import { ApplicationData } from '../impl/application'
 import { AssetData } from '../impl/asset'
@@ -60,8 +60,10 @@ class InternalContext {
     return data
   }
 
-  getApplicationData(id: internal.primitives.StubUint64Compat): ApplicationData {
-    const data = this.ledger.applicationDataMap.get(id)
+  getApplicationData(id: internal.primitives.StubUint64Compat | BaseContract): ApplicationData {
+    const uint64Id =
+      id instanceof BaseContract ? this.ledger.getApplicationForContract(id).id : internal.primitives.Uint64Cls.fromCompat(id)
+    const data = this.ledger.applicationDataMap.get(uint64Id)
     if (!data) {
       throw internal.errors.internalError('Unknown application, check correct testing context is active')
     }

src/impl/inner-transactions.ts

@@ -1,4 +1,10 @@
 import { Account, Application, arc4, Asset, bytes, internal, itxn, TransactionType, uint64 } from '@algorandfoundation/algorand-typescript'
+import { lazyContext } from '../context-helpers/internal-context'
+import { Mutable } from '../typescript-helpers'
+import { asBytes } from '../util'
+import { getApp } from './app-params'
+import { getAsset } from './asset-params'
+import { InnerTxn, InnerTxnFields } from './itxn'
 import {
   ApplicationTransaction,
   AssetConfigTransaction,
@@ -7,12 +13,6 @@ import {
   KeyRegistrationTransaction,
   PaymentTransaction,
 } from './transactions'
-import { asBytes, toBytes } from '../util'
-import { getAsset } from './asset-params'
-import { InnerTxn, InnerTxnFields } from './itxn'
-import { getApp } from './app-params'
-import { Mutable } from '../typescript-helpers'
-import { lazyContext } from '../context-helpers/internal-context'
 
 const mapCommonFields = <T extends InnerTxnFields>(
   fields: T,
@@ -149,7 +149,7 @@ export class ApplicationInnerTxn extends ApplicationTransaction implements itxn.
       approvalProgramPages: Array.isArray(approvalProgram) ? approvalProgram : undefined,
       clearStateProgram: Array.isArray(clearStateProgram) ? undefined : (clearStateProgram as bytes),
       clearStateProgramPages: Array.isArray(clearStateProgram) ? clearStateProgram : undefined,
-      appArgs: appArgs?.map((x) => toBytes(x)),
+      appArgs: appArgs?.map((x) => x),
       accounts: accounts?.map((x) => x),
       assets: assets?.map((x) => x),
       apps: apps?.map((x) => x),

src/impl/transactions.ts

@@ -226,7 +226,7 @@ export class AssetFreezeTransaction extends TransactionBase implements gtxn.Asse
 
 export type ApplicationTransactionFields = TxnFields<gtxn.ApplicationTxn> &
   Partial<{
-    appArgs: Array<bytes>
+    appArgs: Array<unknown>
     accounts: Array<Account>
     assets: Array<Asset>
     apps: Array<Application>
@@ -241,7 +241,7 @@ export class ApplicationTransaction extends TransactionBase implements gtxn.Appl
   static create(fields: ApplicationTransactionFields) {
     return new ApplicationTransaction(fields)
   }
-  #appArgs: Array<bytes>
+  #appArgs: Array<unknown>
   #accounts: Array<Account>
   #assets: Array<Asset>
   #apps: Array<Application>
@@ -308,7 +308,7 @@ export class ApplicationTransaction extends TransactionBase implements gtxn.Appl
     return this.#appLogs.at(-1) ?? lazyContext.getApplicationData(this.appId.id).appLogs.at(-1) ?? Bytes()
   }
   appArgs(index: internal.primitives.StubUint64Compat): bytes {
-    return this.#appArgs[asNumber(index)]
+    return toBytes(this.#appArgs[asNumber(index)])
   }
   accounts(index: internal.primitives.StubUint64Compat): Account {
     return this.#accounts[asNumber(index)]

src/subcontexts/contract-context.ts

@@ -1,7 +1,26 @@
-import { Account, Application, Asset, BaseContract, Bytes, bytes, Contract, LocalState } from '@algorandfoundation/algorand-typescript'
+import {
+  Account,
+  Application,
+  Asset,
+  BaseContract,
+  Bytes,
+  bytes,
+  Contract,
+  contract,
+  internal,
+  LocalState,
+} from '@algorandfoundation/algorand-typescript'
 import { ABIMethod } from 'algosdk'
-import { AbiMetadata, getAbiMetadata, getArc4Signature } from '../abi-metadata'
+import {
+  AbiMetadata,
+  copyAbiMetadatas,
+  getArc4Signature,
+  getContractAbiMetadata,
+  getContractMethodAbiMetadata,
+  isContractProxy,
+} from '../abi-metadata'
 import { BytesMap } from '../collections/custom-key-map'
+import { checkRoutingConditions } from '../context-helpers/context-util'
 import { lazyContext } from '../context-helpers/internal-context'
 import type { TypeInfo } from '../encoders'
 import { AccountCls } from '../impl/account'
@@ -21,6 +40,8 @@ import { getGenericTypeInfo } from '../runtime-helpers'
 import { DeliberateAny, IConstructor } from '../typescript-helpers'
 import { toBytes } from '../util'
 
+type ContractOptionsParameter = Parameters<typeof contract>[0]
+
 type StateTotals = Pick<Application, 'globalNumBytes' | 'globalNumUint' | 'localNumBytes' | 'localNumUint'>
 
 interface States {
@@ -34,7 +55,7 @@ const isUint64GenericType = (typeInfo: TypeInfo | undefined) => {
   return typeInfo.genericArgs.some((t) => t.name.toLocaleLowerCase() === 'uint64')
 }
 
-const extractStates = (contract: BaseContract): States => {
+const extractStates = (contract: BaseContract, contractOptions: ContractOptionsParameter | undefined): States => {
   const stateTotals = { globalNumBytes: 0, globalNumUint: 0, localNumBytes: 0, localNumUint: 0 }
   const states = {
     globalStates: new BytesMap<GlobalStateCls<unknown>>(),
@@ -67,6 +88,12 @@ const extractStates = (contract: BaseContract): States => {
       stateTotals.localNumBytes += isLocalState && !isUint64State ? 1 : 0
     }
   })
+
+  stateTotals.globalNumUint = contractOptions?.stateTotals?.globalUints ?? stateTotals.globalNumUint
+  stateTotals.globalNumBytes = contractOptions?.stateTotals?.globalBytes ?? stateTotals.globalNumBytes
+  stateTotals.localNumUint = contractOptions?.stateTotals?.localUints ?? stateTotals.localNumUint
+  stateTotals.localNumBytes = contractOptions?.stateTotals?.localBytes ?? stateTotals.localNumBytes
+
   return states
 }
 
@@ -142,8 +169,8 @@ export class ContractContext {
   }
 
   private getContractProxyHandler<T extends BaseContract>(isArc4: boolean): ProxyHandler<IConstructor<T>> {
-    const onConstructed = (application: Application, instance: T) => {
-      const states = extractStates(instance)
+    const onConstructed = (application: Application, instance: T, conrtactOptions: ContractOptionsParameter | undefined) => {
+      const states = extractStates(instance, conrtactOptions)
 
       const applicationData = lazyContext.ledger.applicationDataMap.getOrFail(application.id)
       applicationData.application = {
@@ -159,23 +186,33 @@ export class ContractContext {
         let t: T | undefined = undefined
         const application = lazyContext.any.application()
         const txn = lazyContext.any.txn.applicationCall({ appId: application })
+        const appData = lazyContext.ledger.applicationDataMap.getOrFail(application.id)
+        appData.isCreating = true
         lazyContext.txn.ensureScope([txn]).execute(() => {
           t = new target(...args)
         })
+        appData.isCreating = hasCreateMethods(t!)
         const instance = new Proxy(t!, {
           get(target, prop, receiver) {
+            if (prop === isContractProxy) {
+              return true
+            }
             const orig = Reflect.get(target, prop, receiver)
-            const abiMetadata = getAbiMetadata(target, prop as string)
+            const abiMetadata = getContractMethodAbiMetadata(target, prop as string)
             const isProgramMethod = prop === 'approvalProgram' || prop === 'clearStateProgram'
             const isAbiMethod = isArc4 && abiMetadata
             if (isAbiMethod || isProgramMethod) {
               return (...args: DeliberateAny[]): DeliberateAny => {
                 const txns = ContractContext.createMethodCallTxns(receiver, abiMetadata, ...args)
                 return lazyContext.txn.ensureScope(txns).execute(() => {
+                  if (isAbiMethod) {
+                    checkRoutingConditions(application.id, abiMetadata)
+                  }
                   const returnValue = (orig as DeliberateAny).apply(target, args)
                   if (!isProgramMethod && isAbiMethod && returnValue !== undefined) {
                     ;(txns.at(-1) as ApplicationTransaction).logArc4ReturnValue(returnValue)
                   }
+                  appData.isCreating = false
                   return returnValue
                 })
               }
@@ -184,10 +221,22 @@ export class ContractContext {
           },
         })
 
-        onConstructed(application, instance)
+        onConstructed(application, instance, getContractOptions(t!))
+
+        copyAbiMetadatas(t!, instance)
 
         return instance
       },
     }
   }
 }
+
+const getContractOptions = (contract: BaseContract): ContractOptionsParameter | undefined => {
+  const contractClass = contract.constructor as DeliberateAny
+  return contractClass[internal.ContractOptionsSymbol] as ContractOptionsParameter
+}
+
+const hasCreateMethods = (contract: BaseContract) => {
+  const metadatas = getContractAbiMetadata(contract)
+  return Object.values(metadatas).some((metadata) => (metadata.onCreate ?? 'disallow') !== 'disallow')
+}

src/subcontexts/transaction-context.ts

@@ -1,6 +1,6 @@
 import { bytes, Contract, internal, TransactionType, uint64 } from '@algorandfoundation/algorand-typescript'
 import algosdk from 'algosdk'
-import { getAbiMetadata } from '../abi-metadata'
+import { AbiMetadata, getContractMethodAbiMetadata } from '../abi-metadata'
 import { lazyContext } from '../context-helpers/internal-context'
 import { DecodedLogs, decodeLogs, LogDecoding } from '../decode-logs'
 import { testInvariant } from '../errors'
@@ -24,6 +24,7 @@ import {
   PaymentTransaction,
   Transaction,
 } from '../impl/transactions'
+import { FunctionKeys } from '../typescript-helpers'
 import { asBigInt, asNumber, asUint64 } from '../util'
 import { ContractContext } from './contract-context'
 
@@ -48,16 +49,34 @@ interface ExecutionScope {
   execute: <TReturn>(body: () => TReturn) => TReturn
 }
 
+export const checkRoutingConditions = (appId: uint64, metadata: AbiMetadata) => {
+  const appData = lazyContext.getApplicationData(appId)
+  const isCreating = appData.isCreating
+  if (isCreating && metadata.onCreate === 'disallow') {
+    throw new internal.errors.CodeError('method can not be called while creating')
+  }
+  if (!isCreating && metadata.onCreate === 'require') {
+    throw new internal.errors.CodeError('method can only be called while creating')
+  }
+  const txn = lazyContext.activeGroup.activeTransaction
+  if (txn instanceof ApplicationTransaction && metadata.allowActions && !metadata.allowActions.includes(txn.onCompletion)) {
+    throw new internal.errors.CodeError(
+      `method can only be called with one of the following on_completion values: ${metadata.allowActions.join(', ')}`,
+    )
+  }
+}
+
 export class DeferredAppCall<TParams extends unknown[], TReturn> {
   constructor(
     private readonly appId: uint64,
     readonly txns: Transaction[],
     private readonly method: (...args: TParams) => TReturn,
+    private readonly abiMetadata: AbiMetadata,
     private readonly args: TParams,
   ) {}
 
   submit(): TReturn {
-    // TODO: check_routing_conditions
+    checkRoutingConditions(this.appId, this.abiMetadata)
     return this.method(...this.args)
   }
 }
@@ -125,15 +144,16 @@ export class TransactionContext {
     activeTransaction.appendLog(value)
   }
 
-  deferAppCall<TParams extends unknown[], TReturn>(
-    contract: Contract,
+  deferAppCall<TContract extends Contract, TParams extends unknown[], TReturn>(
+    contract: TContract,
     method: (...args: TParams) => TReturn,
+    methodName: FunctionKeys<TContract>,
     ...args: TParams
   ): DeferredAppCall<TParams, TReturn> {
     const appId = lazyContext.ledger.getApplicationForContract(contract)
-    const abiMetadata = getAbiMetadata(contract, method.name)
+    const abiMetadata = getContractMethodAbiMetadata(contract, methodName as string)
     const txns = ContractContext.createMethodCallTxns(contract, abiMetadata, ...args)
-    return new DeferredAppCall(appId.id, txns, method, args)
+    return new DeferredAppCall(appId.id, txns, method, abiMetadata, args)
   }
 
   exportLogs<const T extends [...LogDecoding[]]>(appId: uint64, ...decoding: T): DecodedLogs<T> {