refactor: add tests for method selector

- fix: ApplicationTransaction.appId should return `0` when app `isCreating`
- fix: set correct default active transaction index in group when using
  deferred app calls

Author: boblat

src/impl/transactions.ts

@@ -243,10 +243,11 @@ export class ApplicationTransaction extends TransactionBase implements gtxn.Appl
   #approvalProgramPages: Array<bytes>
   #clearStateProgramPages: Array<bytes>
   #appLogs: Array<bytes>
+  #appId: ApplicationType
 
   protected constructor(fields: ApplicationTransactionFields) {
     super(fields)
-    this.appId = fields.appId ?? Application()
+    this.#appId = fields.appId ?? Application()
     this.onCompletion = fields.onCompletion ?? 'NoOp'
     this.globalNumUint = fields.globalNumUint ?? Uint64(0)
     this.globalNumBytes = fields.globalNumBytes ?? Uint64(0)
@@ -264,7 +265,20 @@ export class ApplicationTransaction extends TransactionBase implements gtxn.Appl
     Object.entries(fields.scratchSpace ?? {}).forEach(([k, v]) => this.setScratchSlot(Number(k), v))
   }
 
-  readonly appId: ApplicationType
+  get backingAppId(): ApplicationType {
+    return this.#appId
+  }
+
+  get appId(): ApplicationType {
+    if (asNumber(this.#appId.id) === 0) {
+      return this.#appId
+    }
+    const appData = lazyContext.getApplicationData(this.#appId.id)
+    if (appData && appData.isCreating) {
+      return Application(0)
+    }
+    return this.#appId
+  }
   readonly onCompletion: arc4.OnCompleteActionStr
   readonly globalNumUint: uint64
   readonly globalNumBytes: uint64

src/subcontexts/contract-context.ts

@@ -1,13 +1,15 @@
-import type { Account, Application, Asset, bytes, contract, LocalState } from '@algorandfoundation/algorand-typescript'
+import type { Account, Application, Asset, contract, LocalState } from '@algorandfoundation/algorand-typescript'
+import type { ARC4Encoded } from '@algorandfoundation/algorand-typescript/arc4'
 import type { AbiMetadata } from '../abi-metadata'
 import { copyAbiMetadatas, getArc4Selector, 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 { toBytes, type TypeInfo } from '../encoders'
+import { type TypeInfo } from '../encoders'
 import { CodeError } from '../errors'
 import { BaseContract, ContractOptionsSymbol } from '../impl/base-contract'
 import { Contract } from '../impl/contract'
+import { getArc4Encoded, UintNImpl } from '../impl/encoded-types'
 import { Bytes } from '../impl/primitives'
 import { AccountCls, ApplicationCls, AssetCls } from '../impl/reference'
 import { BoxCls, BoxMapCls, BoxRefCls, GlobalStateCls } from '../impl/state'
@@ -22,7 +24,6 @@ import {
 } from '../impl/transactions'
 import { getGenericTypeInfo } from '../runtime-helpers'
 import type { DeliberateAny, IConstructor } from '../typescript-helpers'
-
 type ContractOptionsParameter = Parameters<typeof contract>[0]
 
 type StateTotals = Pick<Application, 'globalNumBytes' | 'globalNumUint' | 'localNumBytes' | 'localNumUint'>
@@ -80,28 +81,43 @@ const extractStates = (contract: BaseContract, contractOptions: ContractOptionsP
   return states
 }
 
+const getUintN8Impl = (value: number) => new UintNImpl({ name: 'UintN<8>', genericArgs: [{ name: '8' }] }, value)
+
 const extractArraysFromArgs = (app: Application, methodSelector: Uint8Array, args: DeliberateAny[]) => {
   const transactions: Transaction[] = []
-  const accounts: Account[] = []
+  const accounts: Account[] = [lazyContext.defaultSender]
   const apps: Application[] = [app]
   const assets: Asset[] = []
-  const appArgs: bytes[] = []
+  let appArgs: ARC4Encoded[] = []
 
   for (const arg of args) {
     if (isTransaction(arg)) {
       transactions.push(arg)
     } else if (arg instanceof AccountCls) {
-      appArgs.push(toBytes(accounts.length))
+      appArgs.push(getUintN8Impl(accounts.length))
       accounts.push(arg as Account)
     } else if (arg instanceof ApplicationCls) {
-      appArgs.push(toBytes(apps.length))
+      appArgs.push(getUintN8Impl(apps.length))
       apps.push(arg as Application)
     } else if (arg instanceof AssetCls) {
-      appArgs.push(toBytes(assets.length))
+      appArgs.push(getUintN8Impl(assets.length))
       assets.push(arg as Asset)
+    } else {
+      appArgs.push(arg)
     }
   }
-  return { accounts, apps, assets, transactions, appArgs: [Bytes(methodSelector), ...appArgs] }
+
+  if (appArgs.length > 15) {
+    const packed = getArc4Encoded(appArgs.slice(14))
+    appArgs = [...appArgs.slice(0, 14), packed]
+  }
+  return {
+    accounts,
+    apps,
+    assets,
+    transactions,
+    appArgs: [Bytes(methodSelector), ...appArgs.filter((a) => a !== undefined).map((a) => a.bytes)],
+  }
 }
 
 function isTransaction(obj: unknown): obj is Transaction {

src/subcontexts/ledger-context.ts

@@ -55,13 +55,9 @@ export class LedgerContext {
    * Retrieves an account by address.
    * @param address - The account address.
    * @returns The account.
-   * @throws If the account is unknown.
    */
-  getAccount(address: AccountType): AccountType {
-    if (this.accountDataMap.has(address)) {
-      return new AccountCls(address.bytes)
-    }
-    throw new InternalError('Unknown account, check correct testing context is active')
+  getAccount(address: AccountType | StubBytesCompat): AccountType {
+    return new AccountCls(address instanceof AccountCls ? address.bytes : asBytes(address as StubBytesCompat))
   }
 
   /**

src/subcontexts/transaction-context.ts

@@ -93,8 +93,18 @@ export class TransactionContext {
     group: Array<Transaction | DeferredAppCall<DeliberateAny[], DeliberateAny>>,
     activeTransactionIndex?: number,
   ): ExecutionScope {
+    let activeIndex = activeTransactionIndex
     const transactions = group.map((t) => (t instanceof DeferredAppCall ? t.txns : [t])).flat()
-    const transactionGroup = new TransactionGroup(transactions, activeTransactionIndex)
+    if (activeIndex === undefined) {
+      const lastAppCall = group
+        .filter((t) => t instanceof DeferredAppCall)
+        .at(-1)
+        ?.txns.at(-1)
+      if (lastAppCall) {
+        activeIndex = transactions.indexOf(lastAppCall)
+      }
+    }
+    const transactionGroup = new TransactionGroup(transactions, activeIndex)
 
     this.#activeGroup = transactionGroup
 
@@ -252,11 +262,12 @@ export class TransactionGroup {
    * @throws If there are no transactions in the group or the active transaction is not an application call.
    */
   get activeApplicationId() {
+    // this should return the true app_id and not 0 if the app is in the creation phase
     if (this.transactions.length === 0) {
       throw new InternalError('No transactions in the group')
     }
     testInvariant(this.activeTransaction.type === TransactionType.ApplicationCall, 'No app_id found in the active transaction')
-    return this.activeTransaction.appId.id
+    return (this.activeTransaction as ApplicationTransaction).backingAppId.id
   }
 
   /* @internal */