@algorandfoundation/algorand-typescript-testing 1.0.0-alpha.11 → 1.0.0-alpha.12

package/abi-metadata.d.ts

@@ -2,15 +2,19 @@ import { BaseContract, Contract } from '@algorandfoundation/algorand-typescript'
 import { AbiMethodConfig, BareMethodConfig, CreateOptions, OnCompleteActionStr } from '@algorandfoundation/algorand-typescript/arc4';
 export interface AbiMetadata {
     methodName: string;
-    methodSelector: string;
+    methodSignature: string | undefined;
     argTypes: string[];
     returnType: string;
     onCreate?: CreateOptions;
     allowActions?: OnCompleteActionStr[];
 }
+export declare const isContractProxy: unique symbol;
 export declare const attachAbiMetadata: (contract: {
     new (): Contract;
 }, methodName: string, metadata: AbiMetadata) => void;
+export declare const copyAbiMetadatas: <T extends BaseContract>(sourceContract: T, targetContract: T) => void;
 export declare const captureMethodConfig: <T extends Contract>(contract: T, methodName: string, config?: AbiMethodConfig<T> | BareMethodConfig) => void;
 export declare const hasAbiMetadata: <T extends Contract>(contract: T) => boolean;
-export declare const getAbiMetadata: <T extends BaseContract>(contract: T, methodName: string) => AbiMetadata;
+export declare const getContractAbiMetadata: <T extends BaseContract>(contract: T) => Record<string, AbiMetadata>;
+export declare const getContractMethodAbiMetadata: <T extends BaseContract>(contract: T, methodName: string) => AbiMetadata;
+export declare const getArc4Signature: (metadata: AbiMetadata) => string;

package/context-helpers/context-util.d.ts

@@ -0,0 +1,3 @@
+import { uint64 } from '@algorandfoundation/algorand-typescript';
+import { AbiMetadata } from '../abi-metadata';
+export declare const checkRoutingConditions: (appId: uint64, metadata: AbiMetadata) => void;

package/context-helpers/internal-context.d.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';
@@ -20,7 +20,7 @@ declare class InternalContext {
     get activeGroup(): TransactionGroup;
     getAccountData(account: Account): AccountData;
     getAssetData(id: internal.primitives.StubUint64Compat): AssetData;
-    getApplicationData(id: internal.primitives.StubUint64Compat): ApplicationData;
+    getApplicationData(id: internal.primitives.StubUint64Compat | BaseContract): ApplicationData;
 }
 export declare const lazyContext: InternalContext;
 export {};

package/impl/encoded-types.d.ts

@@ -13,6 +13,7 @@ export declare class UintNImpl<N extends BitSize> extends UintN<N> {
     equals(other: this): boolean;
     static fromBytesImpl(value: internal.primitives.StubBytesCompat | Uint8Array, typeInfo: string | TypeInfo, prefix?: 'none' | 'log'): UintNImpl<BitSize>;
     static getMaxBitsLength(typeInfo: TypeInfo): BitSize;
+    static getArc4TypeName: (t: TypeInfo) => string;
 }
 export declare class UFixedNxMImpl<N extends BitSize, M extends number> extends UFixedNxM<N, M> {
     private value;
@@ -25,6 +26,7 @@ export declare class UFixedNxMImpl<N extends BitSize, M extends number> extends
     equals(other: this): boolean;
     static fromBytesImpl(value: internal.primitives.StubBytesCompat | Uint8Array, typeInfo: string | TypeInfo, prefix?: 'none' | 'log'): UFixedNxM<BitSize, number>;
     static getMaxBitsLength(typeInfo: TypeInfo): BitSize;
+    static getArc4TypeName: (t: TypeInfo) => string;
 }
 export declare class ByteImpl extends Byte {
     private value;
@@ -73,6 +75,7 @@ export declare class StaticArrayImpl<TItem extends ARC4Encoded, TLength extends
     copy(): StaticArrayImpl<TItem, TLength>;
     static fromBytesImpl(value: internal.primitives.StubBytesCompat | Uint8Array, typeInfo: string | TypeInfo, prefix?: 'none' | 'log'): StaticArrayImpl<ARC4Encoded, number>;
     static getMaxBytesLength(typeInfo: TypeInfo): number;
+    static getArc4TypeName: (t: TypeInfo) => string;
 }
 export declare class AddressImpl extends Address {
     private typeInfo;
@@ -105,6 +108,7 @@ export declare class DynamicArrayImpl<TItem extends ARC4Encoded> extends Dynamic
     push(...values: TItem[]): void;
     pop(): TItem;
     static fromBytesImpl(value: internal.primitives.StubBytesCompat | Uint8Array, typeInfo: string | TypeInfo, prefix?: 'none' | 'log'): DynamicArrayImpl<ARC4Encoded>;
+    static getArc4TypeName: (t: TypeInfo) => string;
     private encodeWithLength;
 }
 export declare class TupleImpl<TTuple extends [ARC4Encoded, ...ARC4Encoded[]]> extends Tuple<TTuple> {
@@ -121,10 +125,12 @@ export declare class TupleImpl<TTuple extends [ARC4Encoded, ...ARC4Encoded[]]> e
     private get items();
     static fromBytesImpl(value: internal.primitives.StubBytesCompat | Uint8Array, typeInfo: string | TypeInfo, prefix?: 'none' | 'log'): TupleImpl<[ARC4Encoded, ...ARC4Encoded[]]>;
     static getMaxBytesLength(typeInfo: TypeInfo): number;
+    static getArc4TypeName: (t: TypeInfo) => string;
 }
 type StructConstraint = Record<string, ARC4Encoded>;
-declare const StructImpl_base: any;
+declare const StructImpl_base: DeliberateAny;
 export declare class StructImpl<T extends StructConstraint> extends StructImpl_base {
+    static [x: string]: any;
     private uint8ArrayValue?;
     private typeInfo;
     genericArgs: Record<string, TypeInfo>;
@@ -133,6 +139,7 @@ export declare class StructImpl<T extends StructConstraint> extends StructImpl_b
     get items(): T;
     private decodeAsProperties;
     static fromBytesImpl(value: internal.primitives.StubBytesCompat | Uint8Array, typeInfo: string | TypeInfo, prefix?: 'none' | 'log'): StructImpl<StructConstraint>;
+    static getArc4TypeName: (t: TypeInfo) => string;
 }
 export declare class DynamicBytesImpl extends DynamicBytes {
     private typeInfo;
@@ -145,6 +152,7 @@ export declare class DynamicBytesImpl extends DynamicBytes {
     get items(): ByteImpl[];
     setItem(_index: number, _value: ByteImpl): void;
     static fromBytesImpl(value: internal.primitives.StubBytesCompat | Uint8Array, typeInfo: string | TypeInfo, prefix?: 'none' | 'log'): DynamicBytesImpl;
+    static getArc4TypeName: (_t: TypeInfo) => string;
 }
 export declare class StaticBytesImpl extends StaticBytes {
     private value;
@@ -158,8 +166,10 @@ export declare class StaticBytesImpl extends StaticBytes {
     setItem(_index: number, _value: ByteImpl): void;
     static fromBytesImpl(value: internal.primitives.StubBytesCompat | Uint8Array, typeInfo: string | TypeInfo, prefix?: 'none' | 'log'): StaticBytesImpl;
     static getMaxBytesLength(typeInfo: TypeInfo): number;
+    static getArc4TypeName: (t: TypeInfo) => string;
 }
 export declare function interpretAsArc4Impl<T extends ARC4Encoded>(typeInfoString: string, bytes: internal.primitives.StubBytesCompat, prefix?: 'none' | 'log'): T;
 export declare const arc4Encoders: Record<string, fromBytes<DeliberateAny>>;
 export declare const getArc4Encoder: <T>(typeInfo: TypeInfo, encoders?: Record<string, fromBytes<DeliberateAny>>) => fromBytes<T>;
+export declare const getArc4TypeName: (typeInfo: TypeInfo) => string | undefined;
 export {};

package/impl/inner-transactions.d.ts

@@ -1,7 +1,7 @@
 import { arc4, itxn, TransactionType, uint64 } from '@algorandfoundation/algorand-typescript';
-import { ApplicationTransaction, AssetConfigTransaction, AssetFreezeTransaction, AssetTransferTransaction, KeyRegistrationTransaction, PaymentTransaction } from './transactions';
-import { InnerTxn, InnerTxnFields } from './itxn';
 import { Mutable } from '../typescript-helpers';
+import { InnerTxn, InnerTxnFields } from './itxn';
+import { ApplicationTransaction, AssetConfigTransaction, AssetFreezeTransaction, AssetTransferTransaction, KeyRegistrationTransaction, PaymentTransaction } from './transactions';
 export declare class PaymentInnerTxn extends PaymentTransaction implements itxn.PaymentInnerTxn {
     readonly isItxn?: true;
     static create(fields: itxn.PaymentFields): PaymentInnerTxn;

package/impl/transactions.d.ts

@@ -91,7 +91,7 @@ export declare class AssetFreezeTransaction extends TransactionBase implements g
     readonly typeBytes: bytes;
 }
 export type ApplicationTransactionFields = TxnFields<gtxn.ApplicationTxn> & Partial<{
-    appArgs: Array<bytes>;
+    appArgs: Array<unknown>;
     accounts: Array<Account>;
     assets: Array<Asset>;
     apps: Array<Application>;

package/index.mjs

@@ -1,6 +1,6 @@
-import { internal, Bytes, Uint64, Account, arc4, Ecdsa, op, Base64, TransactionType, Asset, Application, BigUint, BaseContract, Contract } from '@algorandfoundation/algorand-typescript';
-import algosdk from 'algosdk';
-import { a as asMaybeUint64Cls, b as asUint64, c as asBytes, d as asNumber, M as MAX_BOX_SIZE, t as toBytes, e as asBytesCls, f as asUint8Array, g as conactUint8Arrays, L as LOGIC_DATA_PREFIX, h as asBigInt, i as getObjectReference, j as MIN_TXN_FEE, D as DEFAULT_ACCOUNT_MIN_BALANCE, k as DEFAULT_MAX_TXN_LIFE, Z as ZERO_ADDRESS, l as DEFAULT_ASSET_CREATE_MIN_BALANCE, m as DEFAULT_ASSET_OPT_IN_MIN_BALANCE, n as DEFAULT_GLOBAL_GENESIS_HASH, o as asUint64Cls, p as asMaybeBytesCls, q as asBigUint, B as BITS_IN_BYTE, r as MAX_BYTES_SIZE, s as MAX_UINT8, u as binaryStringToBytes, U as UINT64_SIZE, v as MAX_UINT64, w as Uint64BackedCls, A as ALWAYS_APPROVE_TEAL_PROGRAM, x as BytesBackedCls, y as combineIntoMaxBytePages, z as MAX_ITEMS_IN_LOG, C as ABI_RETURN_VALUE_LOG_PREFIX, E as getRandomBytes, F as getArc4Encoder, G as arc4Encoders, H as getGenericTypeInfo, I as getAbiMetadata, J as iterBigInt, K as getRandomBigInt, N as captureMethodConfig } from './runtime-helpers-DlIX78iw.js';
+import { internal, BaseContract, Bytes, Uint64, Account, arc4, Ecdsa, op, Base64, TransactionType, Asset, Application, BigUint, Contract } from '@algorandfoundation/algorand-typescript';
+import algosdk, { ABIMethod } from 'algosdk';
+import { a as asMaybeUint64Cls, b as asUint64, c as asBytes, t as toBytes, d as asNumber, M as MAX_BOX_SIZE, e as asBytesCls, f as asUint8Array, g as conactUint8Arrays, L as LOGIC_DATA_PREFIX, h as asBigInt, i as getObjectReference, j as MIN_TXN_FEE, D as DEFAULT_ACCOUNT_MIN_BALANCE, k as DEFAULT_MAX_TXN_LIFE, Z as ZERO_ADDRESS, l as DEFAULT_ASSET_CREATE_MIN_BALANCE, m as DEFAULT_ASSET_OPT_IN_MIN_BALANCE, n as DEFAULT_GLOBAL_GENESIS_HASH, o as asUint64Cls, p as asMaybeBytesCls, q as asBigUint, B as BITS_IN_BYTE, r as MAX_BYTES_SIZE, s as MAX_UINT8, u as binaryStringToBytes, U as UINT64_SIZE, v as MAX_UINT64, w as Uint64BackedCls, A as ALWAYS_APPROVE_TEAL_PROGRAM, x as BytesBackedCls, y as combineIntoMaxBytePages, z as MAX_ITEMS_IN_LOG, C as ABI_RETURN_VALUE_LOG_PREFIX, E as getRandomBytes, F as getArc4Encoder, G as arc4Encoders, H as getGenericTypeInfo, I as getArc4Signature, J as isContractProxy, K as getContractMethodAbiMetadata, N as copyAbiMetadatas, O as getContractAbiMetadata, P as iterBigInt, Q as getRandomBigInt, R as captureMethodConfig } from './runtime-helpers-D6TF197l.js';
 import { ec } from 'elliptic';
 import { sha256 as sha256$1 } from 'js-sha256';
 import { sha3_256 as sha3_256$1, keccak256 as keccak256$1 } from 'js-sha3';
@@ -57,7 +57,8 @@ class InternalContext {
         return data;
     }
     getApplicationData(id) {
-        const data = this.ledger.applicationDataMap.get(id);
+        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');
         }
@@ -221,7 +222,7 @@ const AppGlobal = {
         if (!exists) {
             return [Bytes(), false];
         }
-        return [state.value, exists];
+        return [toBytes(state.value), exists];
     },
     getExUint64(a, b) {
         const app = getApp(a);
@@ -263,7 +264,7 @@ const AppLocal = {
         if (!exists) {
             return [Bytes(), false];
         }
-        return [state.value, exists];
+        return [toBytes(state.value), exists];
     },
     getExUint64: function (a, b, c) {
         const app = getApp(b);
@@ -3145,7 +3146,7 @@ class ApplicationTransaction extends TransactionBase {
         return this.#appLogs.at(-1) ?? lazyContext.getApplicationData(this.appId.id).appLogs.at(-1) ?? Bytes();
     }
     appArgs(index) {
-        return this.#appArgs[asNumber(index)];
+        return toBytes(this.#appArgs[asNumber(index)]);
     }
     accounts(index) {
         return this.#accounts[asNumber(index)];
@@ -3295,7 +3296,7 @@ class ApplicationInnerTxn extends ApplicationTransaction {
             approvalProgramPages: Array.isArray(approvalProgram) ? approvalProgram : undefined,
             clearStateProgram: Array.isArray(clearStateProgram) ? undefined : clearStateProgram,
             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),
@@ -3755,12 +3756,27 @@ function BoxRef(options) {
     return new BoxRefCls(options?.key);
 }
 
+const checkRoutingConditions$1 = (appId, metadata) => {
+    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(', ')}`);
+    }
+};
+
 const isUint64GenericType = (typeInfo) => {
     if (!Array.isArray(typeInfo?.genericArgs) || !typeInfo?.genericArgs?.length)
         return false;
     return typeInfo.genericArgs.some((t) => t.name.toLocaleLowerCase() === 'uint64');
 };
-const extractStates = (contract) => {
+const extractStates = (contract, contractOptions) => {
     const stateTotals = { globalNumBytes: 0, globalNumUint: 0, localNumBytes: 0, localNumUint: 0 };
     const states = {
         globalStates: new BytesMap(),
@@ -3796,34 +3812,36 @@ const extractStates = (contract) => {
             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;
 };
-const extractArraysFromArgs = (app, args) => {
+const extractArraysFromArgs = (app, methodSelector, args) => {
     const transactions = [];
     const accounts = [];
     const apps = [app];
     const assets = [];
     const appArgs = [];
-    // 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);
         }
         else if (arg instanceof ApplicationCls) {
-            appArgs.push(asUint64Cls(apps.length).toBytes().asAlgoTs());
+            appArgs.push(toBytes(apps.length));
             apps.push(arg);
         }
         else if (arg instanceof AssetCls) {
-            appArgs.push(asUint64Cls(assets.length).toBytes().asAlgoTs());
+            appArgs.push(toBytes(assets.length));
             assets.push(arg);
         }
     }
-    // TODO: use actual method selector in appArgs
-    return { accounts, apps, assets, transactions, appArgs: [Bytes('method_selector'), ...appArgs] };
+    return { accounts, apps, assets, transactions, appArgs: [Bytes(methodSelector), ...appArgs] };
 };
 function isTransaction(obj) {
     return (obj instanceof PaymentTransaction ||
@@ -3838,10 +3856,10 @@ class ContractContext {
         const proxy = new Proxy(type, this.getContractProxyHandler(this.isArc4(type)));
         return new proxy(...args);
     }
-    static createMethodCallTxns(contract, method, ...args) {
-        const abiMetadata = getAbiMetadata(contract, method.name);
+    static createMethodCallTxns(contract, abiMetadata, ...args) {
         const app = lazyContext.ledger.getApplicationForContract(contract);
-        const { transactions, ...appCallArgs } = extractArraysFromArgs(app, args);
+        const methodSelector = abiMetadata ? ABIMethod.fromSignature(getArc4Signature(abiMetadata)).getSelector() : new Uint8Array();
+        const { transactions, ...appCallArgs } = extractArraysFromArgs(app, methodSelector, args);
         const appTxn = lazyContext.any.txn.applicationCall({
             appId: app,
             ...appCallArgs,
@@ -3865,8 +3883,8 @@ class ContractContext {
         return this.isArc4(proto);
     }
     getContractProxyHandler(isArc4) {
-        const onConstructed = (application, instance) => {
-            const states = extractStates(instance);
+        const onConstructed = (application, instance, conrtactOptions) => {
+            const states = extractStates(instance, conrtactOptions);
             const applicationData = lazyContext.ledger.applicationDataMap.getOrFail(application.id);
             applicationData.application = {
                 ...applicationData.application,
@@ -3881,23 +3899,33 @@ class ContractContext {
                 let t = 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);
+                        const abiMetadata = getContractMethodAbiMetadata(target, prop);
                         const isProgramMethod = prop === 'approvalProgram' || prop === 'clearStateProgram';
                         const isAbiMethod = isArc4 && abiMetadata;
                         if (isAbiMethod || isProgramMethod) {
                             return (...args) => {
-                                const txns = ContractContext.createMethodCallTxns(receiver, orig, ...args);
+                                const txns = ContractContext.createMethodCallTxns(receiver, abiMetadata, ...args);
                                 return lazyContext.txn.ensureScope(txns).execute(() => {
+                                    if (isAbiMethod) {
+                                        checkRoutingConditions$1(application.id, abiMetadata);
+                                    }
                                     const returnValue = orig.apply(target, args);
                                     if (!isProgramMethod && isAbiMethod && returnValue !== undefined) {
                                         txns.at(-1).logArc4ReturnValue(returnValue);
                                     }
+                                    appData.isCreating = false;
                                     return returnValue;
                                 });
                             };
@@ -3905,12 +3933,21 @@ class ContractContext {
                         return orig;
                     },
                 });
-                onConstructed(application, instance);
+                onConstructed(application, instance, getContractOptions(t));
+                copyAbiMetadatas(t, instance);
                 return instance;
             },
         };
     }
 }
+const getContractOptions = (contract) => {
+    const contractClass = contract.constructor;
+    return contractClass[internal.ContractOptionsSymbol];
+};
+const hasCreateMethods = (contract) => {
+    const metadatas = getContractAbiMetadata(contract);
+    return Object.values(metadatas).some((metadata) => (metadata.onCreate ?? 'disallow') !== 'disallow');
+};
 
 class LedgerContext {
     appIdIter = iterBigInt(1001n, MAX_UINT64);
@@ -4068,19 +4105,35 @@ function ScopeGenerator(dispose) {
         },
     };
 }
+const checkRoutingConditions = (appId, metadata) => {
+    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(', ')}`);
+    }
+};
 class DeferredAppCall {
     appId;
     txns;
     method;
+    abiMetadata;
     args;
-    constructor(appId, txns, method, args) {
+    constructor(appId, txns, method, abiMetadata, args) {
         this.appId = appId;
         this.txns = txns;
         this.method = method;
+        this.abiMetadata = abiMetadata;
         this.args = args;
     }
     submit() {
-        // TODO: check_routing_conditions
+        checkRoutingConditions(this.appId, this.abiMetadata);
         return this.method(...this.args);
     }
 }
@@ -4139,10 +4192,11 @@ class TransactionContext {
         }
         activeTransaction.appendLog(value);
     }
-    deferAppCall(contract, method, ...args) {
+    deferAppCall(contract, method, methodName, ...args) {
         const appId = lazyContext.ledger.getApplicationForContract(contract);
-        const txns = ContractContext.createMethodCallTxns(contract, method, ...args);
-        return new DeferredAppCall(appId.id, txns, method, args);
+        const abiMetadata = getContractMethodAbiMetadata(contract, methodName);
+        const txns = ContractContext.createMethodCallTxns(contract, abiMetadata, ...args);
+        return new DeferredAppCall(appId.id, txns, method, abiMetadata, args);
     }
     exportLogs(appId, ...decoding) {
         const transaction = this.lastGroup.transactions
@@ -4473,13 +4527,13 @@ class TestExecutionContext {
     #txnContext;
     #valueGenerator;
     #defaultSender;
-    constructor() {
+    constructor(defaultSenderAddress) {
         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) {
         return new AccountCls(address);