@algorandfoundation/algorand-typescript-testing 1.0.0-alpha.2

package/index.mjs

@@ -0,0 +1,3687 @@
+import { internal, Bytes, Uint64, Account, arc4, op, TransactionType, Asset, Application } from '@algorandfoundation/algorand-typescript';
+import algosdk from 'algosdk';
+import { a as asMaybeUint64Cls, b as asUint64, c as asBigInt, d as asBytesCls, e as asBytes, L as LOGIC_DATA_PREFIX, g as getObjectReference, M as MIN_TXN_FEE, D as DEFAULT_ACCOUNT_MIN_BALANCE, f as DEFAULT_MAX_TXN_LIFE, Z as ZERO_ADDRESS, h as DEFAULT_ASSET_CREATE_MIN_BALANCE, i as DEFAULT_ASSET_OPT_IN_MIN_BALANCE, j as DEFAULT_GLOBAL_GENESIS_HASH, k as asUint64Cls, l as asMaybeBytesCls, m as asBigUint, B as BITS_IN_BYTE, n as MAX_BYTES_SIZE, o as MAX_UINT8, p as binaryStringToBytes, U as UINT64_SIZE, q as MAX_UINT64, r as asNumber, A as ALWAYS_APPROVE_TEAL_PROGRAM, s as combineIntoMaxBytePages, t as MAX_ITEMS_IN_LOG, u as getRandomBytes, v as getAbiMetadata, w as hasAbiMetadata, x as getGenericTypeInfo, y as extractGenericTypeArgs, z as iterBigInt, C as toBytes, E as getRandomBigInt, F as captureMethodConfig } from './runtime-helpers-B6YRp95T.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';
+import { sha512_256 as sha512_256$1 } from 'js-sha512';
+import nacl from 'tweetnacl';
+import { randomBytes } from 'crypto';
+
+/**
+ * For accessing implementation specific functions, with a convenient single entry
+ * point for other modules to import Also allows for a single place to check and
+ * provide.
+ */
+class InternalContext {
+    get value() {
+        return internal.ctxMgr.instance;
+    }
+    get defaultSender() {
+        return this.value.defaultSender;
+    }
+    get ledger() {
+        return this.value.ledger;
+    }
+    get txn() {
+        return this.value.txn;
+    }
+    get contract() {
+        return this.value.contract;
+    }
+    get any() {
+        return this.value.any;
+    }
+    get activeApplication() {
+        return this.ledger.getApplication(this.activeGroup.activeApplicationId);
+    }
+    get activeGroup() {
+        return this.value.txn.activeGroup;
+    }
+    getAccountData(accountPublicKey) {
+        const key = internal.primitives.BytesCls.fromCompat(accountPublicKey);
+        const data = this.ledger.accountDataMap.get(key.toString());
+        if (!data) {
+            throw internal.errors.internalError('Unknown account, check correct testing context is active');
+        }
+        return data;
+    }
+    getAssetData(id) {
+        const key = internal.primitives.Uint64Cls.fromCompat(id);
+        const data = this.ledger.assetDataMap.get(key.asBigInt());
+        if (!data) {
+            throw internal.errors.internalError('Unknown asset, check correct testing context is active');
+        }
+        return data;
+    }
+    getApplicationData(id) {
+        const key = internal.primitives.Uint64Cls.fromCompat(id);
+        const data = this.ledger.applicationDataMap.get(key.asBigInt());
+        if (!data) {
+            throw internal.errors.internalError('Unknown application, check correct testing context is active');
+        }
+        return data;
+    }
+}
+const lazyContext = new InternalContext();
+
+const getAccount = (acct) => {
+    const acctId = asMaybeUint64Cls(acct);
+    if (acctId !== undefined) {
+        const activeTxn = lazyContext.activeGroup.activeTransaction;
+        return activeTxn.accounts(acctId.asAlgoTs());
+    }
+    return acct;
+};
+const balance = (a) => {
+    const acct = getAccount(a);
+    return acct.balance;
+};
+const minBalance = (a) => {
+    const acct = getAccount(a);
+    return acct.minBalance;
+};
+const AcctParams = {
+    acctBalance: function (a) {
+        const acct = getAccount(a);
+        return [acct.balance, acct.balance !== 0];
+    },
+    acctMinBalance: function (a) {
+        const acct = getAccount(a);
+        return [acct.minBalance, acct.balance !== 0];
+    },
+    acctAuthAddr: function (a) {
+        const acct = getAccount(a);
+        return [acct.authAddress, acct.balance !== 0];
+    },
+    acctTotalNumUint: function (a) {
+        const acct = getAccount(a);
+        return [acct.totalNumUint, acct.balance !== 0];
+    },
+    acctTotalNumByteSlice: function (a) {
+        const acct = getAccount(a);
+        return [acct.totalNumByteSlice, acct.balance !== 0];
+    },
+    acctTotalExtraAppPages: function (a) {
+        const acct = getAccount(a);
+        return [acct.totalExtraAppPages, acct.balance !== 0];
+    },
+    acctTotalAppsCreated: function (a) {
+        const acct = getAccount(a);
+        return [acct.totalAppsCreated, acct.balance !== 0];
+    },
+    acctTotalAppsOptedIn: function (a) {
+        const acct = getAccount(a);
+        return [acct.totalAppsOptedIn, acct.balance !== 0];
+    },
+    acctTotalAssetsCreated: function (a) {
+        const acct = getAccount(a);
+        return [acct.totalAssetsCreated, acct.balance !== 0];
+    },
+    acctTotalAssets: function (a) {
+        const acct = getAccount(a);
+        return [acct.totalAssets, acct.balance !== 0];
+    },
+    acctTotalBoxes: function (a) {
+        const acct = getAccount(a);
+        return [acct.totalBoxes, acct.balance !== 0];
+    },
+    acctTotalBoxBytes: function (a) {
+        const acct = getAccount(a);
+        return [acct.totalBoxBytes, acct.balance !== 0];
+    },
+};
+
+const resolveAppIndex = (appIdOrIndex) => {
+    const input = asUint64(appIdOrIndex);
+    if (input >= 1001) {
+        return input;
+    }
+    const txn = lazyContext.activeGroup.activeTransaction;
+    return txn.apps(input).id;
+};
+const getApp = (app) => {
+    try {
+        const appId = asMaybeUint64Cls(app);
+        if (appId !== undefined) {
+            return lazyContext.ledger.getApplication(resolveAppIndex(appId));
+        }
+        return app;
+    }
+    catch {
+        return undefined;
+    }
+};
+const AppParams = {
+    appApprovalProgram: function (a) {
+        const app = getApp(a);
+        return app === undefined ? [Bytes(), false] : [app.approvalProgram, true];
+    },
+    appClearStateProgram: function (a) {
+        const app = getApp(a);
+        return app === undefined ? [Bytes(), false] : [app.clearStateProgram, true];
+    },
+    appGlobalNumUint: function (a) {
+        const app = getApp(a);
+        return app === undefined ? [Uint64(0), false] : [app.globalNumUint, true];
+    },
+    appGlobalNumByteSlice: function (a) {
+        const app = getApp(a);
+        return app === undefined ? [Uint64(0), false] : [app.globalNumBytes, true];
+    },
+    appLocalNumUint: function (a) {
+        const app = getApp(a);
+        return app === undefined ? [Uint64(0), false] : [app.localNumUint, true];
+    },
+    appLocalNumByteSlice: function (a) {
+        const app = getApp(a);
+        return app === undefined ? [Uint64(0), false] : [app.localNumBytes, true];
+    },
+    appExtraProgramPages: function (a) {
+        const app = getApp(a);
+        return app === undefined ? [Uint64(0), false] : [app.extraProgramPages, true];
+    },
+    appCreator: function (a) {
+        const app = getApp(a);
+        return app === undefined ? [Account(), false] : [app.creator, true];
+    },
+    appAddress: function (a) {
+        const app = getApp(a);
+        return app === undefined ? [Account(), false] : [app.address, true];
+    },
+};
+
+const resolveAssetIndex = (assetIdOrIndex) => {
+    const input = asUint64(assetIdOrIndex);
+    if (input >= 1001) {
+        return input;
+    }
+    const txn = lazyContext.activeGroup.activeTransaction;
+    return txn.assets(input).id;
+};
+const getAsset = (asset) => {
+    try {
+        const assetId = asMaybeUint64Cls(asset);
+        if (assetId !== undefined) {
+            return lazyContext.ledger.getAsset(resolveAssetIndex(assetId));
+        }
+        return asset;
+    }
+    catch {
+        return undefined;
+    }
+};
+const AssetParams = {
+    assetTotal: function (a) {
+        const asset = getAsset(a);
+        return asset === undefined ? [Uint64(0), false] : [asset.total, true];
+    },
+    assetDecimals: function (a) {
+        const asset = getAsset(a);
+        return asset === undefined ? [Uint64(0), false] : [asset.decimals, true];
+    },
+    assetDefaultFrozen: function (a) {
+        const asset = getAsset(a);
+        return asset === undefined ? [false, false] : [asset.defaultFrozen, true];
+    },
+    assetUnitName: function (a) {
+        const asset = getAsset(a);
+        return asset === undefined ? [Bytes(), false] : [asset.unitName, true];
+    },
+    assetName: function (a) {
+        const asset = getAsset(a);
+        return asset === undefined ? [Bytes(), false] : [asset.name, true];
+    },
+    assetUrl: function (a) {
+        const asset = getAsset(a);
+        return asset === undefined ? [Bytes(), false] : [asset.url, true];
+    },
+    assetMetadataHash: function (a) {
+        const asset = getAsset(a);
+        return asset === undefined ? [Bytes(), false] : [asset.metadataHash, true];
+    },
+    assetManager: function (a) {
+        const asset = getAsset(a);
+        return asset === undefined ? [Account(), false] : [asset.manager, true];
+    },
+    assetReserve: function (a) {
+        const asset = getAsset(a);
+        return asset === undefined ? [Account(), false] : [asset.reserve, true];
+    },
+    assetFreeze: function (a) {
+        const asset = getAsset(a);
+        return asset === undefined ? [Account(), false] : [asset.freeze, true];
+    },
+    assetClawback: function (a) {
+        const asset = getAsset(a);
+        return asset === undefined ? [Account(), false] : [asset.clawback, true];
+    },
+    assetCreator: function (a) {
+        const asset = getAsset(a);
+        return asset === undefined ? [Account(), false] : [asset.creator, true];
+    },
+};
+
+const getAssetHolding = (acctOrIndex, assetOrIndex) => {
+    const account = getAccount(acctOrIndex);
+    const asset = getAsset(assetOrIndex);
+    if (asset === undefined) {
+        return undefined;
+    }
+    const accountData = lazyContext.getAccountData(account.bytes);
+    const holding = accountData.optedAssets.get(asBigInt(asset.id));
+    if (holding === undefined) {
+        return undefined;
+    }
+    return holding;
+};
+const AssetHolding$1 = {
+    assetBalance: function (a, b) {
+        const holding = getAssetHolding(a, b);
+        return holding === undefined ? [Uint64(0), false] : [holding.balance, true];
+    },
+    assetFrozen: function (a, b) {
+        const holding = getAssetHolding(a, b);
+        return holding === undefined ? [false, false] : [holding.frozen, true];
+    },
+};
+
+class NotImplementedError extends Error {
+    constructor(feature) {
+        super(`${feature} is not available in test context. Mock using your preferred testing framework.`);
+    }
+}
+function notImplementedError(feature) {
+    throw new NotImplementedError(feature);
+}
+function testInvariant(condition, message) {
+    if (!condition) {
+        throw new internal.errors.InternalError(message);
+    }
+}
+
+const sha256 = (a) => {
+    const bytesA = internal.primitives.BytesCls.fromCompat(a);
+    const hashArray = sha256$1.create().update(bytesA.asUint8Array()).digest();
+    const hashBytes = internal.primitives.BytesCls.fromCompat(new Uint8Array(hashArray));
+    return hashBytes.asAlgoTs();
+};
+const sha3_256 = (a) => {
+    const bytesA = internal.primitives.BytesCls.fromCompat(a);
+    const hashArray = sha3_256$1.create().update(bytesA.asUint8Array()).digest();
+    const hashBytes = internal.primitives.BytesCls.fromCompat(new Uint8Array(hashArray));
+    return hashBytes.asAlgoTs();
+};
+const keccak256 = (a) => {
+    const bytesA = internal.primitives.BytesCls.fromCompat(a);
+    const hashArray = keccak256$1.create().update(bytesA.asUint8Array()).digest();
+    const hashBytes = internal.primitives.BytesCls.fromCompat(new Uint8Array(hashArray));
+    return hashBytes.asAlgoTs();
+};
+const sha512_256 = (a) => {
+    const bytesA = internal.primitives.BytesCls.fromCompat(a);
+    const hashArray = sha512_256$1.create().update(bytesA.asUint8Array()).digest();
+    const hashBytes = internal.primitives.BytesCls.fromCompat(new Uint8Array(hashArray));
+    return hashBytes.asAlgoTs();
+};
+const ed25519verifyBare = (a, b, c) => {
+    const bytesA = internal.primitives.BytesCls.fromCompat(a);
+    const bytesB = internal.primitives.BytesCls.fromCompat(b);
+    const bytesC = internal.primitives.BytesCls.fromCompat(c);
+    return nacl.sign.detached.verify(bytesA.asUint8Array(), bytesB.asUint8Array(), bytesC.asUint8Array());
+};
+const ed25519verify = (a, b, c) => {
+    const txn = lazyContext.activeGroup.activeTransaction;
+    const programBytes = asBytesCls(txn.onCompletion == arc4.OnCompleteAction[arc4.OnCompleteAction.ClearState] ? txn.clearStateProgram : txn.approvalProgram);
+    const logicSig = new algosdk.LogicSig(programBytes.asUint8Array());
+    const decodedAddress = algosdk.decodeAddress(logicSig.address());
+    const addressBytes = asBytes(decodedAddress.publicKey);
+    const data = LOGIC_DATA_PREFIX.concat(addressBytes).concat(asBytes(a));
+    return ed25519verifyBare(data, b, c);
+};
+const ecdsaVerify = (v, a, b, c, d, e) => {
+    const dataBytes = internal.primitives.BytesCls.fromCompat(a);
+    const sigRBytes = internal.primitives.BytesCls.fromCompat(b);
+    const sigSBytes = internal.primitives.BytesCls.fromCompat(c);
+    const pubkeyXBytes = internal.primitives.BytesCls.fromCompat(d);
+    const pubkeyYBytes = internal.primitives.BytesCls.fromCompat(e);
+    const publicKey = internal.primitives.BytesCls.fromCompat(new Uint8Array([0x04]))
+        .concat(pubkeyXBytes)
+        .concat(pubkeyYBytes);
+    const ecdsa = new ec(curveMap[v]);
+    const keyPair = ecdsa.keyFromPublic(publicKey.asUint8Array());
+    return keyPair.verify(dataBytes.asUint8Array(), { r: sigRBytes.asUint8Array(), s: sigSBytes.asUint8Array() });
+};
+const ecdsaPkRecover = (v, a, b, c, d) => {
+    if (v !== internal.opTypes.Ecdsa.Secp256k1) {
+        internal.errors.internalError(`Unsupported ECDSA curve: ${v}`);
+    }
+    const dataBytes = internal.primitives.BytesCls.fromCompat(a);
+    const rBytes = internal.primitives.BytesCls.fromCompat(c);
+    const sBytes = internal.primitives.BytesCls.fromCompat(d);
+    const recoveryId = internal.primitives.Uint64Cls.fromCompat(b);
+    const ecdsa = new ec(curveMap[v]);
+    const pubKey = ecdsa.recoverPubKey(dataBytes.asUint8Array(), { r: rBytes.asUint8Array(), s: sBytes.asUint8Array() }, recoveryId.asNumber());
+    const x = pubKey.getX().toArray('be');
+    const y = pubKey.getY().toArray('be');
+    return [Bytes(new Uint8Array(x)), Bytes(new Uint8Array(y))];
+};
+const ecdsaPkDecompress = (v, a) => {
+    const bytesA = internal.primitives.BytesCls.fromCompat(a);
+    const ecdsa = new ec(curveMap[v]);
+    const keyPair = ecdsa.keyFromPublic(bytesA.asUint8Array());
+    const pubKey = keyPair.getPublic();
+    const x = pubKey.getX().toArray('be');
+    const y = pubKey.getY().toArray('be');
+    return [Bytes(new Uint8Array(x)), Bytes(new Uint8Array(y))];
+};
+const vrfVerify = (_s, _a, _b, _c) => {
+    notImplementedError('vrfVerify');
+};
+const EllipticCurve = new Proxy({}, {
+    get: (_target, prop) => {
+        notImplementedError(`EllipticCurve.${prop.toString()}`);
+    },
+});
+const curveMap = {
+    [internal.opTypes.Ecdsa.Secp256k1]: 'secp256k1',
+    [internal.opTypes.Ecdsa.Secp256r1]: 'p256',
+};
+
+class GlobalData {
+    minTxnFee;
+    minBalance;
+    maxTxnLife;
+    zeroAddress;
+    logicSigVersion;
+    round;
+    latestTimestamp;
+    groupId;
+    callerApplicationId;
+    assetCreateMinBalance;
+    assetOptInMinBalance;
+    genesisHash;
+    opcodeBudget;
+    constructor() {
+        this.minTxnFee = Uint64(MIN_TXN_FEE);
+        this.minBalance = Uint64(DEFAULT_ACCOUNT_MIN_BALANCE);
+        this.maxTxnLife = Uint64(DEFAULT_MAX_TXN_LIFE);
+        this.zeroAddress = Account(ZERO_ADDRESS);
+        this.callerApplicationId = Uint64(0);
+        this.assetCreateMinBalance = Uint64(DEFAULT_ASSET_CREATE_MIN_BALANCE);
+        this.assetOptInMinBalance = Uint64(DEFAULT_ASSET_OPT_IN_MIN_BALANCE);
+        this.genesisHash = DEFAULT_GLOBAL_GENESIS_HASH;
+    }
+}
+const getGlobalData = () => {
+    return lazyContext.ledger.globalData;
+};
+const getMissingValueErrorMessage = (name) => `'algopy.Global' object has no value set for attribute named '${name}'. Use \`context.ledger.patchGlobalData({${name}: your_value})\` to set the value in your test setup."`;
+const Global = {
+    /**
+     * microalgos
+     */
+    get minTxnFee() {
+        return getGlobalData().minTxnFee;
+    },
+    /**
+     * microalgos
+     */
+    get minBalance() {
+        return getGlobalData().minBalance;
+    },
+    /**
+     * rounds
+     */
+    get maxTxnLife() {
+        return getGlobalData().maxTxnLife;
+    },
+    /**
+     * 32 byte address of all zero bytes
+     */
+    get zeroAddress() {
+        return getGlobalData().zeroAddress;
+    },
+    /**
+     * Number of transactions in this atomic transaction group. At least 1
+     */
+    get groupSize() {
+        const currentTransactionGroup = lazyContext.activeGroup.transactions;
+        return Uint64(currentTransactionGroup.length);
+    },
+    /**
+     * Maximum supported version
+     */
+    get logicSigVersion() {
+        const data = getGlobalData();
+        if (data.logicSigVersion !== undefined)
+            return data.logicSigVersion;
+        throw new internal.errors.InternalError(getMissingValueErrorMessage('logicSigVersion'));
+    },
+    /**
+     * Current round number. Application mode only.
+     */
+    get round() {
+        const data = getGlobalData();
+        if (data.round !== undefined)
+            return data.round;
+        return Uint64(lazyContext.txn.groups.length + 1);
+    },
+    /**
+     * Last confirmed block UNIX timestamp. Fails if negative. Application mode only.
+     */
+    get latestTimestamp() {
+        const data = getGlobalData();
+        if (data.latestTimestamp !== undefined)
+            return data.latestTimestamp;
+        return Uint64(lazyContext.activeGroup.latestTimestamp);
+    },
+    /**
+     * ID of current application executing. Application mode only.
+     */
+    get currentApplicationId() {
+        return lazyContext.activeApplication;
+    },
+    /**
+     * Address of the creator of the current application. Application mode only.
+     */
+    get creatorAddress() {
+        const app = lazyContext.activeApplication;
+        return app.creator;
+    },
+    /**
+     * Address that the current application controls. Application mode only.
+     */
+    get currentApplicationAddress() {
+        const appAddress = algosdk.getApplicationAddress(asBigInt(this.currentApplicationId.id));
+        return Account(Bytes(appAddress));
+    },
+    /**
+     * ID of the transaction group. 32 zero bytes if the transaction is not part of a group.
+     */
+    get groupId() {
+        const data = getGlobalData();
+        if (data.groupId !== undefined)
+            return data.groupId;
+        const reference = getObjectReference(lazyContext.activeGroup);
+        const referenceBytes = Bytes(internal.encodingUtil.bigIntToUint8Array(reference));
+        return op.sha256(referenceBytes);
+    },
+    /**
+     * The remaining cost that can be spent by opcodes in this program.
+     */
+    get opcodeBudget() {
+        const data = getGlobalData();
+        if (data.opcodeBudget !== undefined)
+            return data.opcodeBudget;
+        throw new internal.errors.InternalError(getMissingValueErrorMessage('opcodeBudget'));
+    },
+    /**
+     * The application ID of the application that called this application. 0 if this application is at the top-level. Application mode only.
+     */
+    get callerApplicationId() {
+        return getGlobalData().callerApplicationId;
+    },
+    /**
+     * The application address of the application that called this application. ZeroAddress if this application is at the top-level. Application mode only.
+     */
+    get callerApplicationAddress() {
+        const appAddress = algosdk.getApplicationAddress(asBigInt(this.callerApplicationId));
+        return Account(Bytes(appAddress));
+    },
+    /**
+     * The additional minimum balance required to create (and opt-in to) an asset.
+     */
+    get assetCreateMinBalance() {
+        return getGlobalData().assetCreateMinBalance;
+    },
+    /**
+     * The additional minimum balance required to opt-in to an asset.
+     */
+    get assetOptInMinBalance() {
+        return getGlobalData().assetOptInMinBalance;
+    },
+    /**
+     * The Genesis Hash for the network.
+     */
+    get genesisHash() {
+        return getGlobalData().genesisHash;
+    },
+};
+
+const GTxn = {
+    sender(t) {
+        return lazyContext.activeGroup.getTransaction(t).sender;
+    },
+    fee(t) {
+        return lazyContext.activeGroup.getTransaction(t).fee;
+    },
+    firstValid(t) {
+        return lazyContext.activeGroup.getTransaction(t).firstValid;
+    },
+    firstValidTime(t) {
+        return lazyContext.activeGroup.getTransaction(t).firstValidTime;
+    },
+    lastValid(t) {
+        return lazyContext.activeGroup.getTransaction(t).lastValid;
+    },
+    note(t) {
+        return lazyContext.activeGroup.getTransaction(t).note;
+    },
+    lease(t) {
+        return lazyContext.activeGroup.getTransaction(t).lease;
+    },
+    receiver(t) {
+        return lazyContext.activeGroup.getPaymentTransaction(t).receiver;
+    },
+    amount(t) {
+        return lazyContext.activeGroup.getPaymentTransaction(t).amount;
+    },
+    closeRemainderTo(t) {
+        return lazyContext.activeGroup.getPaymentTransaction(t).closeRemainderTo;
+    },
+    votePk(t) {
+        return lazyContext.activeGroup.getKeyRegistrationTransaction(t).voteKey;
+    },
+    selectionPk(t) {
+        return lazyContext.activeGroup.getKeyRegistrationTransaction(t).selectionKey;
+    },
+    voteFirst(t) {
+        return lazyContext.activeGroup.getKeyRegistrationTransaction(t).voteFirst;
+    },
+    voteLast(t) {
+        return lazyContext.activeGroup.getKeyRegistrationTransaction(t).voteLast;
+    },
+    voteKeyDilution(t) {
+        return lazyContext.activeGroup.getKeyRegistrationTransaction(t).voteKeyDilution;
+    },
+    type(t) {
+        return asUint64Cls(lazyContext.activeGroup.getTransaction(t).type).toBytes().asAlgoTs();
+    },
+    typeEnum(t) {
+        return asUint64(lazyContext.activeGroup.getTransaction(t).type);
+    },
+    xferAsset(t) {
+        return lazyContext.activeGroup.getAssetTransferTransaction(t).xferAsset;
+    },
+    assetAmount(t) {
+        return lazyContext.activeGroup.getAssetTransferTransaction(t).assetAmount;
+    },
+    assetSender(t) {
+        return lazyContext.activeGroup.getAssetTransferTransaction(t).assetSender;
+    },
+    assetReceiver(t) {
+        return lazyContext.activeGroup.getAssetTransferTransaction(t).assetReceiver;
+    },
+    assetCloseTo(t) {
+        return lazyContext.activeGroup.getAssetTransferTransaction(t).assetCloseTo;
+    },
+    groupIndex(t) {
+        return lazyContext.activeGroup.getTransaction(t).groupIndex;
+    },
+    txId(t) {
+        return lazyContext.activeGroup.getTransaction(t).txnId;
+    },
+    applicationId(t) {
+        return lazyContext.activeGroup.getApplicationTransaction(t).appId;
+    },
+    onCompletion(t) {
+        const onCompletionStr = lazyContext.activeGroup.getApplicationTransaction(t).onCompletion;
+        return asUint64(arc4.OnCompleteAction[onCompletionStr]);
+    },
+    applicationArgs(a, b) {
+        return lazyContext.activeGroup.getApplicationTransaction(a).appArgs(asUint64(b));
+    },
+    numAppArgs(t) {
+        return lazyContext.activeGroup.getApplicationTransaction(t).numAppArgs;
+    },
+    accounts(a, b) {
+        return lazyContext.activeGroup.getApplicationTransaction(a).accounts(asUint64(b));
+    },
+    numAccounts(t) {
+        return lazyContext.activeGroup.getApplicationTransaction(t).numAccounts;
+    },
+    approvalProgram(t) {
+        return lazyContext.activeGroup.getApplicationTransaction(t).approvalProgram;
+    },
+    clearStateProgram(t) {
+        return lazyContext.activeGroup.getApplicationTransaction(t).clearStateProgram;
+    },
+    rekeyTo(t) {
+        return lazyContext.activeGroup.getTransaction(t).rekeyTo;
+    },
+    configAsset(t) {
+        return lazyContext.activeGroup.getAssetConfigTransaction(t).configAsset;
+    },
+    configAssetTotal(t) {
+        return lazyContext.activeGroup.getAssetConfigTransaction(t).total;
+    },
+    configAssetDecimals(t) {
+        return lazyContext.activeGroup.getAssetConfigTransaction(t).decimals;
+    },
+    configAssetDefaultFrozen(t) {
+        return lazyContext.activeGroup.getAssetConfigTransaction(t).defaultFrozen;
+    },
+    configAssetUnitName(t) {
+        return lazyContext.activeGroup.getAssetConfigTransaction(t).unitName;
+    },
+    configAssetName(t) {
+        return lazyContext.activeGroup.getAssetConfigTransaction(t).assetName;
+    },
+    configAssetUrl(t) {
+        return lazyContext.activeGroup.getAssetConfigTransaction(t).url;
+    },
+    configAssetMetadataHash(t) {
+        return lazyContext.activeGroup.getAssetConfigTransaction(t).metadataHash;
+    },
+    configAssetManager(t) {
+        return lazyContext.activeGroup.getAssetConfigTransaction(t).manager;
+    },
+    configAssetReserve(t) {
+        return lazyContext.activeGroup.getAssetConfigTransaction(t).reserve;
+    },
+    configAssetFreeze(t) {
+        return lazyContext.activeGroup.getAssetConfigTransaction(t).freeze;
+    },
+    configAssetClawback(t) {
+        return lazyContext.activeGroup.getAssetConfigTransaction(t).clawback;
+    },
+    freezeAsset(t) {
+        return lazyContext.activeGroup.getAssetFreezeTransaction(t).freezeAsset;
+    },
+    freezeAssetAccount(t) {
+        return lazyContext.activeGroup.getAssetFreezeTransaction(t).freezeAccount;
+    },
+    freezeAssetFrozen(t) {
+        return lazyContext.activeGroup.getAssetFreezeTransaction(t).frozen;
+    },
+    assets(a, b) {
+        return lazyContext.activeGroup.getApplicationTransaction(a).assets(asUint64(b));
+    },
+    numAssets(t) {
+        return lazyContext.activeGroup.getApplicationTransaction(t).numAssets;
+    },
+    applications(a, b) {
+        return lazyContext.activeGroup.getApplicationTransaction(a).apps(asUint64(b));
+    },
+    numApplications(t) {
+        return lazyContext.activeGroup.getApplicationTransaction(t).numApps;
+    },
+    globalNumUint(t) {
+        return lazyContext.activeGroup.getApplicationTransaction(t).globalNumUint;
+    },
+    globalNumByteSlice(t) {
+        return lazyContext.activeGroup.getApplicationTransaction(t).globalNumBytes;
+    },
+    localNumUint(t) {
+        return lazyContext.activeGroup.getApplicationTransaction(t).localNumUint;
+    },
+    localNumByteSlice(t) {
+        return lazyContext.activeGroup.getApplicationTransaction(t).localNumBytes;
+    },
+    extraProgramPages(t) {
+        return lazyContext.activeGroup.getApplicationTransaction(t).extraProgramPages;
+    },
+    nonparticipation(t) {
+        return lazyContext.activeGroup.getKeyRegistrationTransaction(t).nonparticipation;
+    },
+    logs(a, b) {
+        return lazyContext.activeGroup.getApplicationTransaction(a).logs(asUint64(b));
+    },
+    numLogs(t) {
+        return lazyContext.activeGroup.getApplicationTransaction(t).numLogs;
+    },
+    createdAssetId(t) {
+        return lazyContext.activeGroup.getAssetConfigTransaction(t).createdAsset;
+    },
+    createdApplicationId(t) {
+        return lazyContext.activeGroup.getApplicationTransaction(t).createdApp;
+    },
+    lastLog(t) {
+        return lazyContext.activeGroup.getApplicationTransaction(t).lastLog;
+    },
+    stateProofPk(t) {
+        return lazyContext.activeGroup.getKeyRegistrationTransaction(t).stateProofKey;
+    },
+    approvalProgramPages(a, b) {
+        return lazyContext.activeGroup.getApplicationTransaction(a).approvalProgramPages(asUint64(b));
+    },
+    numApprovalProgramPages(t) {
+        return lazyContext.activeGroup.getApplicationTransaction(t).numApprovalProgramPages;
+    },
+    clearStateProgramPages(a, b) {
+        return lazyContext.activeGroup.getApplicationTransaction(a).clearStateProgramPages(asUint64(b));
+    },
+    numClearStateProgramPages(t) {
+        return lazyContext.activeGroup.getApplicationTransaction(t).numClearStateProgramPages;
+    },
+};
+
+const addw = (a, b) => {
+    const uint64A = internal.primitives.Uint64Cls.fromCompat(a);
+    const uint64B = internal.primitives.Uint64Cls.fromCompat(b);
+    const sum = uint64A.asBigInt() + uint64B.asBigInt();
+    return toUint128(sum);
+};
+const base64Decode = (e, a) => {
+    const encoding = e === internal.opTypes.Base64.StdEncoding ? 'base64' : 'base64url';
+    const bytesValue = internal.primitives.BytesCls.fromCompat(a);
+    const stringValue = bytesValue.toString();
+    const bufferResult = Buffer.from(stringValue, encoding);
+    if (bufferResult.toString(encoding) !== stringValue) {
+        internal.errors.avmError('illegal base64 data');
+    }
+    const uint8ArrayResult = new Uint8Array(bufferResult);
+    return asBytes(uint8ArrayResult);
+};
+const bitLength = (a) => {
+    const uint64Cls = asMaybeUint64Cls(a);
+    const bigUintCls = asMaybeBytesCls(a)?.toBigUint();
+    const bigIntValue = (uint64Cls?.asBigInt() ?? bigUintCls?.asBigInt());
+    const binaryValue = bigIntValue === 0n ? '' : bigIntValue.toString(2);
+    return Uint64(binaryValue.length);
+};
+const bsqrt = (a) => {
+    const bigUintClsValue = internal.primitives.BigUintCls.fromCompat(a);
+    const bigintValue = internal.primitives.checkBigUint(bigUintClsValue.asBigInt());
+    const sqrtValue = squareroot(bigintValue);
+    return asBigUint(sqrtValue);
+};
+const btoi = (a) => {
+    const bytesValue = internal.primitives.BytesCls.fromCompat(a);
+    if (bytesValue.length.asAlgoTs() > BITS_IN_BYTE) {
+        internal.errors.avmError(`btoi arg too long, got [${bytesValue.length.valueOf()}]bytes`);
+    }
+    return bytesValue.toUint64().asAlgoTs();
+};
+const bzero = (a) => {
+    const size = internal.primitives.Uint64Cls.fromCompat(a).asBigInt();
+    if (size > MAX_BYTES_SIZE) {
+        internal.errors.avmError('bzero attempted to create a too large string');
+    }
+    return Bytes(new Uint8Array(Array(Number(size)).fill(0x00)));
+};
+const concat = (a, b) => {
+    const bytesA = internal.primitives.BytesCls.fromCompat(a);
+    const bytesB = internal.primitives.BytesCls.fromCompat(b);
+    return bytesA.concat(bytesB).asAlgoTs();
+};
+const divmodw = (a, b, c, d) => {
+    const i = uint128ToBigInt(a, b);
+    const j = uint128ToBigInt(c, d);
+    const div = i / j;
+    const mod = i % j;
+    return [...toUint128(div), ...toUint128(mod)];
+};
+const divw = (a, b, c) => {
+    const i = uint128ToBigInt(a, b);
+    const j = internal.primitives.Uint64Cls.fromCompat(c).asBigInt();
+    return Uint64(i / j);
+};
+const exp = (a, b) => {
+    const base = internal.primitives.Uint64Cls.fromCompat(a).asBigInt();
+    const exponent = internal.primitives.Uint64Cls.fromCompat(b).asBigInt();
+    if (base === 0n && exponent === 0n) {
+        throw internal.errors.codeError('0 ** 0 is undefined');
+    }
+    return Uint64(base ** exponent);
+};
+const expw = (a, b) => {
+    const base = internal.primitives.Uint64Cls.fromCompat(a).asBigInt();
+    const exponent = internal.primitives.Uint64Cls.fromCompat(b).asBigInt();
+    if (base === 0n && exponent === 0n) {
+        throw internal.errors.codeError('0 ** 0 is undefined');
+    }
+    return toUint128(base ** exponent);
+};
+const extract = (a, b, c) => {
+    const bytesValue = internal.primitives.BytesCls.fromCompat(a);
+    const bytesLength = bytesValue.length.asBigInt();
+    const start = internal.primitives.Uint64Cls.fromCompat(b).asBigInt();
+    const length = internal.primitives.Uint64Cls.fromCompat(c).asBigInt();
+    let end = start + length;
+    if ((typeof b === 'number' || typeof b === 'bigint') && (typeof c === 'number' || typeof c === 'bigint') && length === 0n) {
+        end = bytesLength;
+    }
+    if (start > bytesLength) {
+        internal.errors.codeError(`extraction start ${start} is beyond length`);
+    }
+    if (end > bytesLength) {
+        internal.errors.codeError(`extraction end ${end} is beyond length`);
+    }
+    return bytesValue.slice(start, end).asAlgoTs();
+};
+const extractUint16 = (a, b) => {
+    const result = extract(a, b, 2);
+    const bytesResult = internal.primitives.BytesCls.fromCompat(result);
+    return bytesResult.toUint64().asAlgoTs();
+};
+const extractUint32 = (a, b) => {
+    const result = extract(a, b, 4);
+    const bytesResult = internal.primitives.BytesCls.fromCompat(result);
+    return bytesResult.toUint64().asAlgoTs();
+};
+const extractUint64 = (a, b) => {
+    const result = extract(a, b, 8);
+    const bytesResult = internal.primitives.BytesCls.fromCompat(result);
+    return bytesResult.toUint64().asAlgoTs();
+};
+const getBit = (a, b) => {
+    const binaryString = toBinaryString(a);
+    const index = internal.primitives.Uint64Cls.fromCompat(b).asNumber();
+    const adjustedIndex = asMaybeUint64Cls(a) ? binaryString.length - index - 1 : index;
+    if (adjustedIndex < 0 || adjustedIndex >= binaryString.length) {
+        internal.errors.codeError(`getBit index ${index} is beyond length`);
+    }
+    return binaryString[adjustedIndex] === '1' ? Uint64(1) : Uint64(0);
+};
+const getByte = (a, b) => {
+    const bytesValue = internal.primitives.BytesCls.fromCompat(a);
+    const index = internal.primitives.Uint64Cls.fromCompat(b).asNumber();
+    if (index >= bytesValue.length.asNumber()) {
+        internal.errors.codeError(`getBytes index ${index} is beyond length`);
+    }
+    return bytesValue.at(index).toUint64().asAlgoTs();
+};
+const itob = (a) => {
+    return asUint64Cls(a).toBytes().asAlgoTs();
+};
+const mulw = (a, b) => {
+    const uint64A = internal.primitives.Uint64Cls.fromCompat(a);
+    const uint64B = internal.primitives.Uint64Cls.fromCompat(b);
+    const product = uint64A.asBigInt() * uint64B.asBigInt();
+    return toUint128(product);
+};
+const replace = (a, b, c) => {
+    const bytesValue = internal.primitives.BytesCls.fromCompat(a);
+    const index = internal.primitives.Uint64Cls.fromCompat(b).asNumber();
+    const replacement = internal.primitives.BytesCls.fromCompat(c);
+    const valueLength = bytesValue.length.asNumber();
+    const replacementLength = replacement.length.asNumber();
+    if (index + replacementLength > valueLength) {
+        internal.errors.codeError(`expected value <= ${valueLength}, got: ${index + replacementLength}`);
+    }
+    return bytesValue
+        .slice(0, index)
+        .concat(replacement)
+        .concat(bytesValue.slice(index + replacementLength, valueLength))
+        .asAlgoTs();
+};
+const select = ((a, b, c) => {
+    const uint64A = asMaybeUint64Cls(a);
+    const uint64B = asMaybeUint64Cls(b);
+    const bytesA = asMaybeBytesCls(a);
+    const bytesB = asMaybeBytesCls(b);
+    const bigIntC = internal.primitives.Uint64Cls.fromCompat(c).asBigInt();
+    return (bigIntC !== 0n ? (uint64B ?? bytesB) : (uint64A ?? bytesA)).asAlgoTs();
+});
+const setBit = ((a, b, c) => {
+    const uint64Cls = asMaybeUint64Cls(a);
+    const bytesCls = asMaybeBytesCls(a);
+    const binaryString = toBinaryString((uint64Cls ?? bytesCls));
+    const isUint64 = !!uint64Cls;
+    const indexFromLeft = internal.primitives.Uint64Cls.fromCompat(b).asNumber();
+    const indexFromRight = binaryString.length - indexFromLeft - 1;
+    const bit = internal.primitives.Uint64Cls.fromCompat(c).asNumber();
+    const newBytes = doSetBit(binaryString, isUint64 ? indexFromRight : indexFromLeft, bit);
+    return isUint64 ? newBytes.toUint64().asAlgoTs() : newBytes.asAlgoTs();
+});
+const setByte = (a, b, c) => {
+    const binaryString = toBinaryString(a);
+    const byteIndex = internal.primitives.Uint64Cls.fromCompat(b).asNumber();
+    const bitIndex = byteIndex * BITS_IN_BYTE;
+    const replacementNumber = internal.primitives.Uint64Cls.fromCompat(c).asBigInt();
+    const replacement = replacementNumber === 0n ? '0'.repeat(BITS_IN_BYTE) : toBinaryString(c, true);
+    if (bitIndex >= binaryString.length) {
+        internal.errors.codeError(`setByte index ${byteIndex} is beyond length`);
+    }
+    if (replacementNumber > MAX_UINT8) {
+        internal.errors.codeError(`setByte value ${replacementNumber} > ${MAX_UINT8}`);
+    }
+    const updatedString = binaryString.slice(0, bitIndex) + replacement + binaryString.slice(bitIndex + replacement.length);
+    const updatedBytes = binaryStringToBytes(updatedString);
+    return updatedBytes.asAlgoTs();
+};
+const shl = (a, b) => {
+    const uint64A = internal.primitives.Uint64Cls.fromCompat(a);
+    const uint64B = internal.primitives.Uint64Cls.fromCompat(b);
+    const bigIntA = uint64A.asBigInt();
+    const bigIntB = uint64B.asBigInt();
+    if (bigIntB >= UINT64_SIZE) {
+        internal.errors.codeError(`shl value ${bigIntB} >= ${UINT64_SIZE}`);
+    }
+    const shifted = (bigIntA * 2n ** bigIntB) % 2n ** BigInt(UINT64_SIZE);
+    return Uint64(shifted);
+};
+const shr = (a, b) => {
+    const uint64A = internal.primitives.Uint64Cls.fromCompat(a);
+    const uint64B = internal.primitives.Uint64Cls.fromCompat(b);
+    const bigIntA = uint64A.asBigInt();
+    const bigIntB = uint64B.asBigInt();
+    if (bigIntB >= UINT64_SIZE) {
+        internal.errors.codeError(`shr value ${bigIntB} >= ${UINT64_SIZE}`);
+    }
+    const shifted = bigIntA / 2n ** bigIntB;
+    return Uint64(shifted);
+};
+const sqrt = (a) => {
+    const bigIntValue = internal.primitives.Uint64Cls.fromCompat(a).asBigInt();
+    const sqrtValue = squareroot(bigIntValue);
+    return Uint64(sqrtValue);
+};
+const substring = (a, b, c) => {
+    const bytesValue = internal.primitives.BytesCls.fromCompat(a);
+    const start = internal.primitives.Uint64Cls.fromCompat(b).asBigInt();
+    const end = internal.primitives.Uint64Cls.fromCompat(c).asBigInt();
+    if (start > end) {
+        internal.errors.codeError('substring end before start');
+    }
+    if (end > bytesValue.length.asNumber()) {
+        internal.errors.codeError('substring range beyond length of string');
+    }
+    return bytesValue.slice(start, end).asAlgoTs();
+};
+const JsonRef = new Proxy({}, {
+    get: (_target, prop) => {
+        notImplementedError(`JsonRef.${prop.toString()}`);
+    },
+});
+const squareroot = (x) => {
+    let lo = 0n, hi = x;
+    while (lo <= hi) {
+        const mid = (lo + hi) / 2n;
+        if (mid * mid > x)
+            hi = mid - 1n;
+        else
+            lo = mid + 1n;
+    }
+    return hi;
+};
+const toUint128 = (value) => {
+    const cf = value >> 64n;
+    const rest = value & MAX_UINT64;
+    return [Uint64(cf), Uint64(rest)];
+};
+const uint128ToBigInt = (a, b) => {
+    const bigIntA = internal.primitives.Uint64Cls.fromCompat(a).asBigInt();
+    const bigIntB = internal.primitives.Uint64Cls.fromCompat(b).asBigInt();
+    return (bigIntA << 64n) + bigIntB;
+};
+const toBinaryString = (a, isDynamic = false) => {
+    const uint64Cls = asMaybeUint64Cls(a);
+    const bytesCls = asMaybeBytesCls(a);
+    let binaryString = '';
+    if (uint64Cls) {
+        binaryString = [...uint64Cls.toBytes(isDynamic).asUint8Array()].map((x) => x.toString(2).padStart(BITS_IN_BYTE, '0')).join('');
+    }
+    else if (bytesCls) {
+        binaryString = [...bytesCls.asUint8Array()].map((x) => x.toString(2).padStart(BITS_IN_BYTE, '0')).join('');
+    }
+    else {
+        internal.errors.codeError('unknown type for argument a');
+    }
+    return binaryString;
+};
+const doSetBit = (binaryString, index, bit) => {
+    if (index < 0 || index >= binaryString.length) {
+        internal.errors.codeError(`setBit index ${index < 0 ? binaryString.length - index : index} is beyond length`);
+    }
+    if (bit !== 0 && bit !== 1) {
+        internal.errors.codeError(`setBit value > 1`);
+    }
+    const updatedString = binaryString.slice(0, index) + bit.toString() + binaryString.slice(index + 1);
+    return binaryStringToBytes(updatedString);
+};
+
+// import {
+//   getApplicationTransaction,
+//   getAssetConfigTransaction,
+//   getAssetFreezeTransaction,
+//   getAssetTransferTransaction,
+//   getKeyRegistrationTransaction,
+//   getPaymentTransaction,
+//   getTransaction,
+// } from './gtxn'
+const gaid = (a) => {
+    const group = lazyContext.activeGroup;
+    const transaction = group.transactions[asNumber(a)];
+    if (transaction.type === TransactionType.ApplicationCall) {
+        return transaction.createdApp.id;
+    }
+    else if (transaction.type === TransactionType.AssetConfig) {
+        return transaction.createdAsset.id;
+    }
+    else {
+        throw new internal.errors.InternalError(`transaction at index ${asNumber(a)} is not an Application Call or Asset Config`);
+    }
+};
+const Txn = {
+    get sender() {
+        return lazyContext.activeGroup.getTransaction().sender;
+    },
+    /**
+     * microalgos
+     */
+    get fee() {
+        return lazyContext.activeGroup.getTransaction().fee;
+    },
+    /**
+     * round number
+     */
+    get firstValid() {
+        return lazyContext.activeGroup.getTransaction().firstValid;
+    },
+    /**
+     * UNIX timestamp of block before txn.FirstValid. Fails if negative
+     */
+    get firstValidTime() {
+        return lazyContext.activeGroup.getTransaction().firstValidTime;
+    },
+    /**
+     * round number
+     */
+    get lastValid() {
+        return lazyContext.activeGroup.getTransaction().lastValid;
+    },
+    /**
+     * Any data up to 1024 bytes
+     */
+    get note() {
+        return lazyContext.activeGroup.getTransaction().note;
+    },
+    /**
+     * 32 byte lease value
+     */
+    get lease() {
+        return lazyContext.activeGroup.getTransaction().lease;
+    },
+    /**
+     * 32 byte address
+     */
+    get receiver() {
+        return lazyContext.activeGroup.getPaymentTransaction().receiver;
+    },
+    /**
+     * microalgos
+     */
+    get amount() {
+        return lazyContext.activeGroup.getPaymentTransaction().amount;
+    },
+    /**
+     * 32 byte address
+     */
+    get closeRemainderTo() {
+        return lazyContext.activeGroup.getPaymentTransaction().closeRemainderTo;
+    },
+    /**
+     * 32 byte address
+     */
+    get votePk() {
+        return lazyContext.activeGroup.getKeyRegistrationTransaction().voteKey;
+    },
+    /**
+     * 32 byte address
+     */
+    get selectionPk() {
+        return lazyContext.activeGroup.getKeyRegistrationTransaction().selectionKey;
+    },
+    /**
+     * The first round that the participation key is valid.
+     */
+    get voteFirst() {
+        return lazyContext.activeGroup.getKeyRegistrationTransaction().voteFirst;
+    },
+    /**
+     * The last round that the participation key is valid.
+     */
+    get voteLast() {
+        return lazyContext.activeGroup.getKeyRegistrationTransaction().voteLast;
+    },
+    /**
+     * Dilution for the 2-level participation key
+     */
+    get voteKeyDilution() {
+        return lazyContext.activeGroup.getKeyRegistrationTransaction().voteKeyDilution;
+    },
+    /**
+     * Transaction type as bytes
+     */
+    get type() {
+        return asUint64Cls(lazyContext.activeGroup.getTransaction().type).toBytes().asAlgoTs();
+    },
+    /**
+     * Transaction type as integer
+     */
+    get typeEnum() {
+        return asUint64(lazyContext.activeGroup.getTransaction().type);
+    },
+    /**
+     * Asset ID
+     */
+    get xferAsset() {
+        return lazyContext.activeGroup.getAssetTransferTransaction().xferAsset;
+    },
+    /**
+     * value in Asset's units
+     */
+    get assetAmount() {
+        return lazyContext.activeGroup.getAssetTransferTransaction().assetAmount;
+    },
+    /**
+     * 32 byte address. Source of assets if Sender is the Asset's Clawback address.
+     */
+    get assetSender() {
+        return lazyContext.activeGroup.getAssetTransferTransaction().assetSender;
+    },
+    /**
+     * 32 byte address
+     */
+    get assetReceiver() {
+        return lazyContext.activeGroup.getAssetTransferTransaction().assetReceiver;
+    },
+    /**
+     * 32 byte address
+     */
+    get assetCloseTo() {
+        return lazyContext.activeGroup.getAssetTransferTransaction().assetCloseTo;
+    },
+    /**
+     * Position of this transaction within an atomic transaction group. A stand-alone transaction is implicitly element 0 in a group of 1
+     */
+    get groupIndex() {
+        return lazyContext.activeGroup.getTransaction().groupIndex;
+    },
+    /**
+     * The computed ID for this transaction. 32 bytes.
+     */
+    get txId() {
+        return lazyContext.activeGroup.getTransaction().txnId;
+    },
+    /**
+     * ApplicationID from ApplicationCall transaction
+     */
+    get applicationId() {
+        return lazyContext.activeGroup.getApplicationTransaction().appId;
+    },
+    /**
+     * ApplicationCall transaction on completion action
+     */
+    get onCompletion() {
+        const onCompletionStr = lazyContext.activeGroup.getApplicationTransaction().onCompletion;
+        return asUint64(arc4.OnCompleteAction[onCompletionStr]);
+    },
+    /**
+     * Arguments passed to the application in the ApplicationCall transaction
+     */
+    applicationArgs(a) {
+        return lazyContext.activeGroup.getApplicationTransaction().appArgs(asUint64(a));
+    },
+    /**
+     * Number of ApplicationArgs
+     */
+    get numAppArgs() {
+        return lazyContext.activeGroup.getApplicationTransaction().numAppArgs;
+    },
+    /**
+     * Accounts listed in the ApplicationCall transaction
+     */
+    accounts(a) {
+        return lazyContext.activeGroup.getApplicationTransaction().accounts(asUint64(a));
+    },
+    /**
+     * Number of Accounts
+     */
+    get numAccounts() {
+        return lazyContext.activeGroup.getApplicationTransaction().numAccounts;
+    },
+    /**
+     * Approval program
+     */
+    get approvalProgram() {
+        return lazyContext.activeGroup.getApplicationTransaction().approvalProgram;
+    },
+    /**
+     * Clear state program
+     */
+    get clearStateProgram() {
+        return lazyContext.activeGroup.getApplicationTransaction().clearStateProgram;
+    },
+    /**
+     * 32 byte Sender's new AuthAddr
+     */
+    get rekeyTo() {
+        return lazyContext.activeGroup.getTransaction().rekeyTo;
+    },
+    /**
+     * Asset ID in asset config transaction
+     */
+    get configAsset() {
+        return lazyContext.activeGroup.getAssetConfigTransaction().configAsset;
+    },
+    /**
+     * Total number of units of this asset created
+     */
+    get configAssetTotal() {
+        return lazyContext.activeGroup.getAssetConfigTransaction().total;
+    },
+    /**
+     * Number of digits to display after the decimal place when displaying the asset
+     */
+    get configAssetDecimals() {
+        return lazyContext.activeGroup.getAssetConfigTransaction().decimals;
+    },
+    /**
+     * Whether the asset's slots are frozen by default or not, 0 or 1
+     */
+    get configAssetDefaultFrozen() {
+        return lazyContext.activeGroup.getAssetConfigTransaction().defaultFrozen;
+    },
+    /**
+     * Unit name of the asset
+     */
+    get configAssetUnitName() {
+        return lazyContext.activeGroup.getAssetConfigTransaction().unitName;
+    },
+    /**
+     * The asset name
+     */
+    get configAssetName() {
+        return lazyContext.activeGroup.getAssetConfigTransaction().assetName;
+    },
+    /**
+     * URL
+     */
+    get configAssetUrl() {
+        return lazyContext.activeGroup.getAssetConfigTransaction().url;
+    },
+    /**
+     * 32 byte commitment to unspecified asset metadata
+     */
+    get configAssetMetadataHash() {
+        return lazyContext.activeGroup.getAssetConfigTransaction().metadataHash;
+    },
+    /**
+     * 32 byte address
+     */
+    get configAssetManager() {
+        return lazyContext.activeGroup.getAssetConfigTransaction().manager;
+    },
+    /**
+     * 32 byte address
+     */
+    get configAssetReserve() {
+        return lazyContext.activeGroup.getAssetConfigTransaction().reserve;
+    },
+    /**
+     * 32 byte address
+     */
+    get configAssetFreeze() {
+        return lazyContext.activeGroup.getAssetConfigTransaction().freeze;
+    },
+    /**
+     * 32 byte address
+     */
+    get configAssetClawback() {
+        return lazyContext.activeGroup.getAssetConfigTransaction().clawback;
+    },
+    /**
+     * Asset ID being frozen or un-frozen
+     */
+    get freezeAsset() {
+        return lazyContext.activeGroup.getAssetFreezeTransaction().freezeAsset;
+    },
+    /**
+     * 32 byte address of the account whose asset slot is being frozen or un-frozen
+     */
+    get freezeAssetAccount() {
+        return lazyContext.activeGroup.getAssetFreezeTransaction().freezeAccount;
+    },
+    /**
+     * The new frozen value, 0 or 1
+     */
+    get freezeAssetFrozen() {
+        return lazyContext.activeGroup.getAssetFreezeTransaction().frozen;
+    },
+    /**
+     * Foreign Assets listed in the ApplicationCall transaction
+     */
+    assets(a) {
+        return lazyContext.activeGroup.getApplicationTransaction().assets(asUint64(a));
+    },
+    /**
+     * Number of Assets
+     */
+    get numAssets() {
+        return lazyContext.activeGroup.getApplicationTransaction().numAssets;
+    },
+    /**
+     * Foreign Apps listed in the ApplicationCall transaction
+     */
+    applications(a) {
+        return lazyContext.activeGroup.getApplicationTransaction().apps(asUint64(a));
+    },
+    /**
+     * Number of Applications
+     */
+    get numApplications() {
+        return lazyContext.activeGroup.getApplicationTransaction().numApps;
+    },
+    /**
+     * Number of global state integers in ApplicationCall
+     */
+    get globalNumUint() {
+        return lazyContext.activeGroup.getApplicationTransaction().globalNumUint;
+    },
+    /**
+     * Number of global state byteslices in ApplicationCall
+     */
+    get globalNumByteSlice() {
+        return lazyContext.activeGroup.getApplicationTransaction().globalNumBytes;
+    },
+    /**
+     * Number of local state integers in ApplicationCall
+     */
+    get localNumUint() {
+        return lazyContext.activeGroup.getApplicationTransaction().localNumUint;
+    },
+    /**
+     * Number of local state byteslices in ApplicationCall
+     */
+    get localNumByteSlice() {
+        return lazyContext.activeGroup.getApplicationTransaction().localNumBytes;
+    },
+    /**
+     * Number of additional pages for each of the application's approval and clear state programs. An ExtraProgramPages of 1 means 2048 more total bytes, or 1024 for each program.
+     */
+    get extraProgramPages() {
+        return lazyContext.activeGroup.getApplicationTransaction().extraProgramPages;
+    },
+    /**
+     * Marks an account nonparticipating for rewards
+     */
+    get nonparticipation() {
+        return lazyContext.activeGroup.getKeyRegistrationTransaction().nonparticipation;
+    },
+    /**
+     * Log messages emitted by an application call (only with `itxn` in v5). Application mode only
+     */
+    logs(a) {
+        return lazyContext.activeGroup.getApplicationTransaction().logs(asUint64(a));
+    },
+    /**
+     * Number of Logs (only with `itxn` in v5). Application mode only
+     */
+    get numLogs() {
+        return lazyContext.activeGroup.getApplicationTransaction().numLogs;
+    },
+    /**
+     * Asset ID allocated by the creation of an ASA (only with `itxn` in v5). Application mode only
+     */
+    get createdAssetId() {
+        return lazyContext.activeGroup.getAssetConfigTransaction().createdAsset;
+    },
+    /**
+     * ApplicationID allocated by the creation of an application (only with `itxn` in v5). Application mode only
+     */
+    get createdApplicationId() {
+        return lazyContext.activeGroup.getApplicationTransaction().createdApp;
+    },
+    /**
+     * The last message emitted. Empty bytes if none were emitted. Application mode only
+     */
+    get lastLog() {
+        return lazyContext.activeGroup.getApplicationTransaction().lastLog;
+    },
+    /**
+     * 64 byte state proof public key
+     */
+    get stateProofPk() {
+        return lazyContext.activeGroup.getKeyRegistrationTransaction().stateProofKey;
+    },
+    /**
+     * Approval Program as an array of pages
+     */
+    approvalProgramPages(a) {
+        return lazyContext.activeGroup.getApplicationTransaction().approvalProgramPages(asUint64(a));
+    },
+    /**
+     * Number of Approval Program pages
+     */
+    get numApprovalProgramPages() {
+        return lazyContext.activeGroup.getApplicationTransaction().numApprovalProgramPages;
+    },
+    /**
+     * ClearState Program as an array of pages
+     */
+    clearStateProgramPages(a) {
+        return lazyContext.activeGroup.getApplicationTransaction().clearStateProgramPages(asUint64(a));
+    },
+    /**
+     * Number of ClearState Program pages
+     */
+    get numClearStateProgramPages() {
+        return lazyContext.activeGroup.getApplicationTransaction().numClearStateProgramPages;
+    },
+};
+
+const GITxn = {
+    sender: function (t) {
+        return lazyContext.activeGroup.getItxnGroup().getInnerTxn(t).sender;
+    },
+    fee: function (t) {
+        return lazyContext.activeGroup.getItxnGroup().getInnerTxn(t).fee;
+    },
+    firstValid: function (t) {
+        return lazyContext.activeGroup.getItxnGroup().getInnerTxn(t).firstValid;
+    },
+    firstValidTime: function (t) {
+        return lazyContext.activeGroup.getItxnGroup().getInnerTxn(t).firstValidTime;
+    },
+    lastValid: function (t) {
+        return lazyContext.activeGroup.getItxnGroup().getInnerTxn(t).lastValid;
+    },
+    note: function (t) {
+        return lazyContext.activeGroup.getItxnGroup().getInnerTxn(t).note;
+    },
+    lease: function (t) {
+        return lazyContext.activeGroup.getItxnGroup().getInnerTxn(t).lease;
+    },
+    receiver: function (t) {
+        return lazyContext.activeGroup.getItxnGroup().getPaymentInnerTxn(t).receiver;
+    },
+    amount: function (t) {
+        return lazyContext.activeGroup.getItxnGroup().getPaymentInnerTxn(t).amount;
+    },
+    closeRemainderTo: function (t) {
+        return lazyContext.activeGroup.getItxnGroup().getPaymentInnerTxn(t).closeRemainderTo;
+    },
+    votePk: function (t) {
+        return lazyContext.activeGroup.getItxnGroup().getKeyRegistrationInnerTxn(t).voteKey;
+    },
+    selectionPk: function (t) {
+        return lazyContext.activeGroup.getItxnGroup().getKeyRegistrationInnerTxn(t).selectionKey;
+    },
+    voteFirst: function (t) {
+        return lazyContext.activeGroup.getItxnGroup().getKeyRegistrationInnerTxn(t).voteFirst;
+    },
+    voteLast: function (t) {
+        return lazyContext.activeGroup.getItxnGroup().getKeyRegistrationInnerTxn(t).voteLast;
+    },
+    voteKeyDilution: function (t) {
+        return lazyContext.activeGroup.getItxnGroup().getKeyRegistrationInnerTxn(t).voteKeyDilution;
+    },
+    type: function (t) {
+        return asUint64Cls(lazyContext.activeGroup.getItxnGroup().getInnerTxn(t).type).toBytes().asAlgoTs();
+    },
+    typeEnum: function (t) {
+        return asUint64(lazyContext.activeGroup.getItxnGroup().getInnerTxn(t).type);
+    },
+    xferAsset: function (t) {
+        return lazyContext.activeGroup.getItxnGroup().getAssetTransferInnerTxn(t).xferAsset;
+    },
+    assetAmount: function (t) {
+        return lazyContext.activeGroup.getItxnGroup().getAssetTransferInnerTxn(t).assetAmount;
+    },
+    assetSender: function (t) {
+        return lazyContext.activeGroup.getItxnGroup().getAssetTransferInnerTxn(t).assetSender;
+    },
+    assetReceiver: function (t) {
+        return lazyContext.activeGroup.getItxnGroup().getAssetTransferInnerTxn(t).assetReceiver;
+    },
+    assetCloseTo: function (t) {
+        return lazyContext.activeGroup.getItxnGroup().getAssetTransferInnerTxn(t).assetCloseTo;
+    },
+    groupIndex: function (t) {
+        return lazyContext.activeGroup.getItxnGroup().getInnerTxn(t).groupIndex;
+    },
+    txId: function (t) {
+        return lazyContext.activeGroup.getItxnGroup().getInnerTxn(t).txnId;
+    },
+    applicationId: function (t) {
+        return lazyContext.activeGroup.getItxnGroup().getApplicationInnerTxn(t).appId;
+    },
+    onCompletion: function (t) {
+        const onCompletionStr = lazyContext.activeGroup.getItxnGroup().getApplicationInnerTxn(t).onCompletion;
+        return asUint64(arc4.OnCompleteAction[onCompletionStr]);
+    },
+    applicationArgs: function (t, a) {
+        return lazyContext.activeGroup.getItxnGroup().getApplicationInnerTxn(t).appArgs(asUint64(a));
+    },
+    numAppArgs: function (t) {
+        return lazyContext.activeGroup.getItxnGroup().getApplicationInnerTxn(t).numAppArgs;
+    },
+    accounts: function (t, a) {
+        return lazyContext.activeGroup.getItxnGroup().getApplicationInnerTxn(t).accounts(asUint64(a));
+    },
+    numAccounts: function (t) {
+        return lazyContext.activeGroup.getItxnGroup().getApplicationInnerTxn(t).numAccounts;
+    },
+    approvalProgram: function (t) {
+        return lazyContext.activeGroup.getItxnGroup().getApplicationInnerTxn(t).approvalProgram;
+    },
+    clearStateProgram: function (t) {
+        return lazyContext.activeGroup.getItxnGroup().getApplicationInnerTxn(t).clearStateProgram;
+    },
+    rekeyTo: function (t) {
+        return lazyContext.activeGroup.getItxnGroup().getInnerTxn(t).rekeyTo;
+    },
+    configAsset: function (t) {
+        return lazyContext.activeGroup.getItxnGroup().getAssetConfigInnerTxn(t).configAsset;
+    },
+    configAssetTotal: function (t) {
+        return lazyContext.activeGroup.getItxnGroup().getAssetConfigInnerTxn(t).total;
+    },
+    configAssetDecimals: function (t) {
+        return lazyContext.activeGroup.getItxnGroup().getAssetConfigInnerTxn(t).decimals;
+    },
+    configAssetDefaultFrozen: function (t) {
+        return lazyContext.activeGroup.getItxnGroup().getAssetConfigInnerTxn(t).defaultFrozen;
+    },
+    configAssetUnitName: function (t) {
+        return lazyContext.activeGroup.getItxnGroup().getAssetConfigInnerTxn(t).unitName;
+    },
+    configAssetName: function (t) {
+        return lazyContext.activeGroup.getItxnGroup().getAssetConfigInnerTxn(t).assetName;
+    },
+    configAssetUrl: function (t) {
+        return lazyContext.activeGroup.getItxnGroup().getAssetConfigInnerTxn(t).url;
+    },
+    configAssetMetadataHash: function (t) {
+        return lazyContext.activeGroup.getItxnGroup().getAssetConfigInnerTxn(t).metadataHash;
+    },
+    configAssetManager: function (t) {
+        return lazyContext.activeGroup.getItxnGroup().getAssetConfigInnerTxn(t).manager;
+    },
+    configAssetReserve: function (t) {
+        return lazyContext.activeGroup.getItxnGroup().getAssetConfigInnerTxn(t).reserve;
+    },
+    configAssetFreeze: function (t) {
+        return lazyContext.activeGroup.getItxnGroup().getAssetConfigInnerTxn(t).freeze;
+    },
+    configAssetClawback: function (t) {
+        return lazyContext.activeGroup.getItxnGroup().getAssetConfigInnerTxn(t).clawback;
+    },
+    freezeAsset: function (t) {
+        return lazyContext.activeGroup.getItxnGroup().getAssetFreezeInnerTxn(t).freezeAsset;
+    },
+    freezeAssetAccount: function (t) {
+        return lazyContext.activeGroup.getItxnGroup().getAssetFreezeInnerTxn(t).freezeAccount;
+    },
+    freezeAssetFrozen: function (t) {
+        return lazyContext.activeGroup.getItxnGroup().getAssetFreezeInnerTxn(t).frozen;
+    },
+    assets: function (t, a) {
+        return lazyContext.activeGroup.getItxnGroup().getApplicationInnerTxn(t).assets(asUint64(a));
+    },
+    numAssets: function (t) {
+        return lazyContext.activeGroup.getItxnGroup().getApplicationInnerTxn(t).numAssets;
+    },
+    applications: function (t, a) {
+        return lazyContext.activeGroup.getItxnGroup().getApplicationInnerTxn(t).apps(asUint64(a));
+    },
+    numApplications: function (t) {
+        return lazyContext.activeGroup.getItxnGroup().getApplicationInnerTxn(t).numApps;
+    },
+    globalNumUint: function (t) {
+        return lazyContext.activeGroup.getItxnGroup().getApplicationInnerTxn(t).globalNumUint;
+    },
+    globalNumByteSlice: function (t) {
+        return lazyContext.activeGroup.getItxnGroup().getApplicationInnerTxn(t).globalNumBytes;
+    },
+    localNumUint: function (t) {
+        return lazyContext.activeGroup.getItxnGroup().getApplicationInnerTxn(t).localNumUint;
+    },
+    localNumByteSlice: function (t) {
+        return lazyContext.activeGroup.getItxnGroup().getApplicationInnerTxn(t).localNumBytes;
+    },
+    extraProgramPages: function (t) {
+        return lazyContext.activeGroup.getItxnGroup().getApplicationInnerTxn(t).extraProgramPages;
+    },
+    nonparticipation: function (t) {
+        return lazyContext.activeGroup.getItxnGroup().getKeyRegistrationInnerTxn(t).nonparticipation;
+    },
+    logs: function (t, a) {
+        return lazyContext.activeGroup.getItxnGroup().getApplicationInnerTxn(t).logs(asUint64(a));
+    },
+    numLogs: function (t) {
+        return lazyContext.activeGroup.getItxnGroup().getApplicationInnerTxn(t).numLogs;
+    },
+    createdAssetId: function (t) {
+        return lazyContext.activeGroup.getItxnGroup().getAssetConfigInnerTxn(t).createdAsset;
+    },
+    createdApplicationId: function (t) {
+        return lazyContext.activeGroup.getItxnGroup().getApplicationInnerTxn(t).createdApp;
+    },
+    lastLog: function (t) {
+        return lazyContext.activeGroup.getItxnGroup().getApplicationInnerTxn(t).lastLog;
+    },
+    stateProofPk: function (t) {
+        return lazyContext.activeGroup.getItxnGroup().getKeyRegistrationInnerTxn(t).stateProofKey;
+    },
+    approvalProgramPages: function (t, a) {
+        return lazyContext.activeGroup.getItxnGroup().getApplicationInnerTxn(t).approvalProgramPages(asUint64(a));
+    },
+    numApprovalProgramPages: function (t) {
+        return lazyContext.activeGroup.getItxnGroup().getApplicationInnerTxn(t).numApprovalProgramPages;
+    },
+    clearStateProgramPages: function (t, a) {
+        return lazyContext.activeGroup.getItxnGroup().getApplicationInnerTxn(t).clearStateProgramPages(asUint64(a));
+    },
+    numClearStateProgramPages: function (t) {
+        return lazyContext.activeGroup.getItxnGroup().getApplicationInnerTxn(t).numClearStateProgramPages;
+    },
+};
+const ITxn = {
+    /**
+     * 32 byte address
+     */
+    get sender() {
+        return lazyContext.activeGroup.getItxnGroup().getInnerTxn().sender;
+    },
+    /**
+     * microalgos
+     */
+    get fee() {
+        return lazyContext.activeGroup.getItxnGroup().getInnerTxn().fee;
+    },
+    /**
+     * round number
+     */
+    get firstValid() {
+        return lazyContext.activeGroup.getItxnGroup().getInnerTxn().firstValid;
+    },
+    /**
+     * UNIX timestamp of block before txn.FirstValid. Fails if negative
+     */
+    get firstValidTime() {
+        return lazyContext.activeGroup.getItxnGroup().getInnerTxn().firstValidTime;
+    },
+    /**
+     * round number
+     */
+    get lastValid() {
+        return lazyContext.activeGroup.getItxnGroup().getInnerTxn().lastValid;
+    },
+    /**
+     * Any data up to 1024 bytes
+     */
+    get note() {
+        return lazyContext.activeGroup.getItxnGroup().getInnerTxn().note;
+    },
+    /**
+     * 32 byte lease value
+     */
+    get lease() {
+        return lazyContext.activeGroup.getItxnGroup().getInnerTxn().lease;
+    },
+    /**
+     * 32 byte address
+     */
+    get receiver() {
+        return lazyContext.activeGroup.getItxnGroup().getPaymentInnerTxn().receiver;
+    },
+    /**
+     * microalgos
+     */
+    get amount() {
+        return lazyContext.activeGroup.getItxnGroup().getPaymentInnerTxn().amount;
+    },
+    /**
+     * 32 byte address
+     */
+    get closeRemainderTo() {
+        return lazyContext.activeGroup.getItxnGroup().getPaymentInnerTxn().closeRemainderTo;
+    },
+    /**
+     * 32 byte address
+     */
+    get votePk() {
+        return lazyContext.activeGroup.getItxnGroup().getKeyRegistrationInnerTxn().voteKey;
+    },
+    /**
+     * 32 byte address
+     */
+    get selectionPk() {
+        return lazyContext.activeGroup.getItxnGroup().getKeyRegistrationInnerTxn().selectionKey;
+    },
+    /**
+     * The first round that the participation key is valid.
+     */
+    get voteFirst() {
+        return lazyContext.activeGroup.getItxnGroup().getKeyRegistrationInnerTxn().voteFirst;
+    },
+    /**
+     * The last round that the participation key is valid.
+     */
+    get voteLast() {
+        return lazyContext.activeGroup.getItxnGroup().getKeyRegistrationInnerTxn().voteLast;
+    },
+    /**
+     * Dilution for the 2-level participation key
+     */
+    get voteKeyDilution() {
+        return lazyContext.activeGroup.getItxnGroup().getKeyRegistrationInnerTxn().voteKeyDilution;
+    },
+    /**
+     * Transaction type as bytes
+     */
+    get type() {
+        return asUint64Cls(lazyContext.activeGroup.getItxnGroup().getInnerTxn().type).toBytes().asAlgoTs();
+    },
+    /**
+     * Transaction type as integer
+     */
+    get typeEnum() {
+        return asUint64(lazyContext.activeGroup.getItxnGroup().getInnerTxn().type);
+    },
+    /**
+     * Asset ID
+     */
+    get xferAsset() {
+        return lazyContext.activeGroup.getItxnGroup().getAssetTransferInnerTxn().xferAsset;
+    },
+    /**
+     * value in Asset's units
+     */
+    get assetAmount() {
+        return lazyContext.activeGroup.getItxnGroup().getAssetTransferInnerTxn().assetAmount;
+    },
+    /**
+     * 32 byte address. Source of assets if Sender is the Asset's Clawback address.
+     */
+    get assetSender() {
+        return lazyContext.activeGroup.getItxnGroup().getAssetTransferInnerTxn().assetSender;
+    },
+    /**
+     * 32 byte address
+     */
+    get assetReceiver() {
+        return lazyContext.activeGroup.getItxnGroup().getAssetTransferInnerTxn().assetReceiver;
+    },
+    /**
+     * 32 byte address
+     */
+    get assetCloseTo() {
+        return lazyContext.activeGroup.getItxnGroup().getAssetTransferInnerTxn().assetCloseTo;
+    },
+    /**
+     * Position of this transaction within an atomic transaction group. A stand-alone transaction is implicitly element 0 in a group of 1
+     */
+    get groupIndex() {
+        return lazyContext.activeGroup.getItxnGroup().getInnerTxn().groupIndex;
+    },
+    /**
+     * The computed ID for this transaction. 32 bytes.
+     */
+    get txId() {
+        return lazyContext.activeGroup.getItxnGroup().getInnerTxn().txnId;
+    },
+    /**
+     * ApplicationID from ApplicationCall transaction
+     */
+    get applicationId() {
+        return lazyContext.activeGroup.getItxnGroup().getApplicationInnerTxn().appId;
+    },
+    /**
+     * ApplicationCall transaction on completion action
+     */
+    get onCompletion() {
+        const onCompletionStr = lazyContext.activeGroup.getItxnGroup().getApplicationInnerTxn().onCompletion;
+        return asUint64(arc4.OnCompleteAction[onCompletionStr]);
+    },
+    /**
+     * Arguments passed to the application in the ApplicationCall transaction
+     */
+    applicationArgs(a) {
+        return lazyContext.activeGroup.getItxnGroup().getApplicationInnerTxn().appArgs(asUint64(a));
+    },
+    /**
+     * Number of ApplicationArgs
+     */
+    get numAppArgs() {
+        return lazyContext.activeGroup.getItxnGroup().getApplicationInnerTxn().numAppArgs;
+    },
+    /**
+     * Accounts listed in the ApplicationCall transaction
+     */
+    accounts(a) {
+        return lazyContext.activeGroup.getItxnGroup().getApplicationInnerTxn().accounts(asUint64(a));
+    },
+    /**
+     * Number of Accounts
+     */
+    get numAccounts() {
+        return lazyContext.activeGroup.getItxnGroup().getApplicationInnerTxn().numAccounts;
+    },
+    /**
+     * Approval program
+     */
+    get approvalProgram() {
+        return lazyContext.activeGroup.getItxnGroup().getApplicationInnerTxn().approvalProgram;
+    },
+    /**
+     * Clear state program
+     */
+    get clearStateProgram() {
+        return lazyContext.activeGroup.getItxnGroup().getApplicationInnerTxn().clearStateProgram;
+    },
+    /**
+     * 32 byte Sender's new AuthAddr
+     */
+    get rekeyTo() {
+        return lazyContext.activeGroup.getItxnGroup().getInnerTxn().rekeyTo;
+    },
+    /**
+     * Asset ID in asset config transaction
+     */
+    get configAsset() {
+        return lazyContext.activeGroup.getItxnGroup().getAssetConfigInnerTxn().configAsset;
+    },
+    /**
+     * Total number of units of this asset created
+     */
+    get configAssetTotal() {
+        return lazyContext.activeGroup.getItxnGroup().getAssetConfigInnerTxn().total;
+    },
+    /**
+     * Number of digits to display after the decimal place when displaying the asset
+     */
+    get configAssetDecimals() {
+        return lazyContext.activeGroup.getItxnGroup().getAssetConfigInnerTxn().decimals;
+    },
+    /**
+     * Whether the asset's slots are frozen by default or not, 0 or 1
+     */
+    get configAssetDefaultFrozen() {
+        return lazyContext.activeGroup.getItxnGroup().getAssetConfigInnerTxn().defaultFrozen;
+    },
+    /**
+     * Unit name of the asset
+     */
+    get configAssetUnitName() {
+        return lazyContext.activeGroup.getItxnGroup().getAssetConfigInnerTxn().unitName;
+    },
+    /**
+     * The asset name
+     */
+    get configAssetName() {
+        return lazyContext.activeGroup.getItxnGroup().getAssetConfigInnerTxn().assetName;
+    },
+    /**
+     * URL
+     */
+    get configAssetUrl() {
+        return lazyContext.activeGroup.getItxnGroup().getAssetConfigInnerTxn().url;
+    },
+    /**
+     * 32 byte commitment to unspecified asset metadata
+     */
+    get configAssetMetadataHash() {
+        return lazyContext.activeGroup.getItxnGroup().getAssetConfigInnerTxn().metadataHash;
+    },
+    /**
+     * 32 byte address
+     */
+    get configAssetManager() {
+        return lazyContext.activeGroup.getItxnGroup().getAssetConfigInnerTxn().manager;
+    },
+    /**
+     * 32 byte address
+     */
+    get configAssetReserve() {
+        return lazyContext.activeGroup.getItxnGroup().getAssetConfigInnerTxn().reserve;
+    },
+    /**
+     * 32 byte address
+     */
+    get configAssetFreeze() {
+        return lazyContext.activeGroup.getItxnGroup().getAssetConfigInnerTxn().freeze;
+    },
+    /**
+     * 32 byte address
+     */
+    get configAssetClawback() {
+        return lazyContext.activeGroup.getItxnGroup().getAssetConfigInnerTxn().clawback;
+    },
+    /**
+     * Asset ID being frozen or un-frozen
+     */
+    get freezeAsset() {
+        return lazyContext.activeGroup.getItxnGroup().getAssetFreezeInnerTxn().freezeAsset;
+    },
+    /**
+     * 32 byte address of the account whose asset slot is being frozen or un-frozen
+     */
+    get freezeAssetAccount() {
+        return lazyContext.activeGroup.getItxnGroup().getAssetFreezeInnerTxn().freezeAccount;
+    },
+    /**
+     * The new frozen value, 0 or 1
+     */
+    get freezeAssetFrozen() {
+        return lazyContext.activeGroup.getItxnGroup().getAssetFreezeInnerTxn().frozen;
+    },
+    /**
+     * Foreign Assets listed in the ApplicationCall transaction
+     */
+    assets(a) {
+        return lazyContext.activeGroup.getItxnGroup().getApplicationInnerTxn().assets(asUint64(a));
+    },
+    /**
+     * Number of Assets
+     */
+    get numAssets() {
+        return lazyContext.activeGroup.getItxnGroup().getApplicationInnerTxn().numAssets;
+    },
+    /**
+     * Foreign Apps listed in the ApplicationCall transaction
+     */
+    applications(a) {
+        return lazyContext.activeGroup.getItxnGroup().getApplicationInnerTxn().apps(asUint64(a));
+    },
+    /**
+     * Number of Applications
+     */
+    get numApplications() {
+        return lazyContext.activeGroup.getItxnGroup().getApplicationInnerTxn().numApps;
+    },
+    /**
+     * Number of global state integers in ApplicationCall
+     */
+    get globalNumUint() {
+        return lazyContext.activeGroup.getItxnGroup().getApplicationInnerTxn().globalNumUint;
+    },
+    /**
+     * Number of global state byteslices in ApplicationCall
+     */
+    get globalNumByteSlice() {
+        return lazyContext.activeGroup.getItxnGroup().getApplicationInnerTxn().globalNumBytes;
+    },
+    /**
+     * Number of local state integers in ApplicationCall
+     */
+    get localNumUint() {
+        return lazyContext.activeGroup.getItxnGroup().getApplicationInnerTxn().localNumUint;
+    },
+    /**
+     * Number of local state byteslices in ApplicationCall
+     */
+    get localNumByteSlice() {
+        return lazyContext.activeGroup.getItxnGroup().getApplicationInnerTxn().localNumBytes;
+    },
+    /**
+     * Number of additional pages for each of the application's approval and clear state programs. An ExtraProgramPages of 1 means 2048 more total bytes, or 1024 for each program.
+     */
+    get extraProgramPages() {
+        return lazyContext.activeGroup.getItxnGroup().getApplicationInnerTxn().extraProgramPages;
+    },
+    /**
+     * Marks an account nonparticipating for rewards
+     */
+    get nonparticipation() {
+        return lazyContext.activeGroup.getItxnGroup().getKeyRegistrationInnerTxn().nonparticipation;
+    },
+    /**
+     * Log messages emitted by an application call (only with `itxn` in v5). Application mode only
+     */
+    logs(a) {
+        return lazyContext.activeGroup.getItxnGroup().getApplicationInnerTxn().logs(asUint64(a));
+    },
+    /**
+     * Number of Logs (only with `itxn` in v5). Application mode only
+     */
+    get numLogs() {
+        return lazyContext.activeGroup.getItxnGroup().getApplicationInnerTxn().numLogs;
+    },
+    /**
+     * Asset ID allocated by the creation of an ASA (only with `itxn` in v5). Application mode only
+     */
+    get createdAssetId() {
+        return lazyContext.activeGroup.getItxnGroup().getAssetConfigInnerTxn().createdAsset;
+    },
+    /**
+     * ApplicationID allocated by the creation of an application (only with `itxn` in v5). Application mode only
+     */
+    get createdApplicationId() {
+        return lazyContext.activeGroup.getItxnGroup().getApplicationInnerTxn().createdApp;
+    },
+    /**
+     * The last message emitted. Empty bytes if none were emitted. Application mode only
+     */
+    get lastLog() {
+        return lazyContext.activeGroup.getItxnGroup().getApplicationInnerTxn().lastLog;
+    },
+    /**
+     * 64 byte state proof public key
+     */
+    get stateProofPk() {
+        return lazyContext.activeGroup.getItxnGroup().getKeyRegistrationInnerTxn().stateProofKey;
+    },
+    /**
+     * Approval Program as an array of pages
+     */
+    approvalProgramPages(a) {
+        return lazyContext.activeGroup.getItxnGroup().getApplicationInnerTxn().approvalProgramPages(asUint64(a));
+    },
+    /**
+     * Number of Approval Program pages
+     */
+    get numApprovalProgramPages() {
+        return lazyContext.activeGroup.getItxnGroup().getApplicationInnerTxn().numApprovalProgramPages;
+    },
+    /**
+     * ClearState Program as an array of pages
+     */
+    clearStateProgramPages(a) {
+        return lazyContext.activeGroup.getItxnGroup().getApplicationInnerTxn().clearStateProgramPages(asUint64(a));
+    },
+    /**
+     * Number of ClearState Program pages
+     */
+    get numClearStateProgramPages() {
+        return lazyContext.activeGroup.getItxnGroup().getApplicationInnerTxn().numClearStateProgramPages;
+    },
+};
+const setConstructingItxnField = (fields) => {
+    Object.assign(lazyContext.activeGroup.constructingItxn, fields);
+};
+const getConstructingItxn = () => {
+    return lazyContext.activeGroup.constructingItxn;
+};
+const ITxnCreate = {
+    begin: function () {
+        lazyContext.activeGroup.beginInnerTransactionGroup();
+    },
+    setSender: function (a) {
+        setConstructingItxnField({ sender: a });
+    },
+    setFee: function (a) {
+        setConstructingItxnField({ fee: asUint64(a) });
+    },
+    setNote: function (a) {
+        setConstructingItxnField({ note: asBytes(a) });
+    },
+    setReceiver: function (a) {
+        setConstructingItxnField({ receiver: a });
+    },
+    setAmount: function (a) {
+        setConstructingItxnField({ amount: asUint64(a) });
+    },
+    setCloseRemainderTo: function (a) {
+        setConstructingItxnField({ closeRemainderTo: a });
+    },
+    setVotePk: function (a) {
+        setConstructingItxnField({ voteKey: asBytes(a) });
+    },
+    setSelectionPk: function (a) {
+        setConstructingItxnField({ selectionKey: asBytes(a) });
+    },
+    setVoteFirst: function (a) {
+        setConstructingItxnField({ voteFirst: asUint64(a) });
+    },
+    setVoteLast: function (a) {
+        setConstructingItxnField({ voteLast: asUint64(a) });
+    },
+    setVoteKeyDilution: function (a) {
+        setConstructingItxnField({ voteKeyDilution: asUint64(a) });
+    },
+    setType: function (a) {
+        setConstructingItxnField({ type: asBytesCls(a).toUint64().asNumber() });
+    },
+    setTypeEnum: function (a) {
+        setConstructingItxnField({ type: asUint64Cls(a).asNumber() });
+    },
+    setXferAsset: function (a) {
+        setConstructingItxnField({ xferAsset: getAsset(a) });
+    },
+    setAssetAmount: function (a) {
+        setConstructingItxnField({ assetAmount: asUint64(a) });
+    },
+    setAssetSender: function (a) {
+        setConstructingItxnField({ assetSender: a });
+    },
+    setAssetReceiver: function (a) {
+        setConstructingItxnField({ assetReceiver: a });
+    },
+    setAssetCloseTo: function (a) {
+        setConstructingItxnField({ assetCloseTo: a });
+    },
+    setApplicationId: function (a) {
+        setConstructingItxnField({ appId: getApp(a) });
+    },
+    setOnCompletion: function (a) {
+        setConstructingItxnField({ onCompletion: asUint64(a) });
+    },
+    setApplicationArgs: function (a) {
+        const appArgs = (getConstructingItxn().appArgs ?? []);
+        appArgs.push(asBytes(a));
+        setConstructingItxnField({ appArgs });
+    },
+    setAccounts: function (a) {
+        const accounts = (getConstructingItxn().accounts ?? []);
+        accounts.push(a);
+        setConstructingItxnField({ accounts });
+    },
+    setApprovalProgram: function (a) {
+        setConstructingItxnField({ approvalProgram: asBytes(a) });
+    },
+    setClearStateProgram: function (a) {
+        setConstructingItxnField({ clearStateProgram: asBytes(a) });
+    },
+    setRekeyTo: function (a) {
+        setConstructingItxnField({ rekeyTo: a });
+    },
+    setConfigAsset: function (a) {
+        setConstructingItxnField({ configAsset: getAsset(a) });
+    },
+    setConfigAssetTotal: function (a) {
+        setConstructingItxnField({ total: asUint64(a) });
+    },
+    setConfigAssetDecimals: function (a) {
+        setConstructingItxnField({ decimals: asUint64(a) });
+    },
+    setConfigAssetDefaultFrozen: function (a) {
+        setConstructingItxnField({ defaultFrozen: a });
+    },
+    setConfigAssetUnitName: function (a) {
+        setConstructingItxnField({ unitName: asBytes(a) });
+    },
+    setConfigAssetName: function (a) {
+        setConstructingItxnField({ assetName: asBytes(a) });
+    },
+    setConfigAssetUrl: function (a) {
+        setConstructingItxnField({ url: asBytes(a) });
+    },
+    setConfigAssetMetadataHash: function (a) {
+        setConstructingItxnField({ metadataHash: asBytes(a) });
+    },
+    setConfigAssetManager: function (a) {
+        setConstructingItxnField({ manager: a });
+    },
+    setConfigAssetReserve: function (a) {
+        setConstructingItxnField({ reserve: a });
+    },
+    setConfigAssetFreeze: function (a) {
+        setConstructingItxnField({ freeze: a });
+    },
+    setConfigAssetClawback: function (a) {
+        setConstructingItxnField({ clawback: a });
+    },
+    setFreezeAsset: function (a) {
+        setConstructingItxnField({ freezeAsset: getAsset(a) });
+    },
+    setFreezeAssetAccount: function (a) {
+        setConstructingItxnField({ freezeAccount: a });
+    },
+    setFreezeAssetFrozen: function (a) {
+        setConstructingItxnField({ frozen: a });
+    },
+    setAssets: function (a) {
+        const asset = getAsset(a);
+        if (asset) {
+            const assets = (getConstructingItxn().assets ?? []);
+            assets.push(asset);
+            setConstructingItxnField({ assets });
+        }
+    },
+    setApplications: function (a) {
+        const app = getApp(a);
+        if (app) {
+            const apps = (getConstructingItxn().apps ?? []);
+            apps.push(app);
+            setConstructingItxnField({ apps });
+        }
+    },
+    setGlobalNumUint: function (a) {
+        setConstructingItxnField({ globalNumUint: asUint64(a) });
+    },
+    setGlobalNumByteSlice: function (a) {
+        setConstructingItxnField({ globalNumBytes: asUint64(a) });
+    },
+    setLocalNumUint: function (a) {
+        setConstructingItxnField({ localNumUint: asUint64(a) });
+    },
+    setLocalNumByteSlice: function (a) {
+        setConstructingItxnField({ localNumBytes: asUint64(a) });
+    },
+    setExtraProgramPages: function (a) {
+        setConstructingItxnField({ extraProgramPages: asUint64(a) });
+    },
+    setNonparticipation: function (a) {
+        setConstructingItxnField({ nonparticipation: a });
+    },
+    setStateProofPk: function (a) {
+        setConstructingItxnField({ stateProofKey: asBytes(a) });
+    },
+    setApprovalProgramPages: function (a) {
+        let pages = (getConstructingItxn().approvalProgram ?? []);
+        if (!Array.isArray(pages)) {
+            pages = [pages];
+        }
+        pages.push(asBytes(a));
+        setConstructingItxnField({ approvalProgram: pages });
+    },
+    setClearStateProgramPages: function (a) {
+        let pages = (getConstructingItxn().clearStateProgram ?? []);
+        if (!Array.isArray(pages)) {
+            pages = [pages];
+        }
+        pages.push(asBytes(a));
+        setConstructingItxnField({ clearStateProgram: pages });
+    },
+    next: function () {
+        lazyContext.activeGroup.appendInnerTransactionGroup();
+    },
+    submit: function () {
+        lazyContext.activeGroup.submitInnerTransactionGroup();
+    },
+};
+
+const Scratch = {
+    loadBytes: function (a) {
+        const result = lazyContext.activeGroup.activeTransaction.getScratchSlot(a);
+        if (result instanceof internal.primitives.BytesCls) {
+            return result;
+        }
+        throw new internal.errors.InternalError('Invalid scratch slot type');
+    },
+    loadUint64: function (a) {
+        const result = lazyContext.activeGroup.activeTransaction.getScratchSlot(a);
+        if (result instanceof internal.primitives.Uint64Cls) {
+            return result;
+        }
+        throw new internal.errors.InternalError('Invalid scratch slot type');
+    },
+    store: function (a, b) {
+        lazyContext.activeGroup.activeTransaction.setScratchSlot(a, b);
+    },
+};
+
+var ops = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AcctParams: AcctParams,
+    AppParams: AppParams,
+    AssetHolding: AssetHolding$1,
+    AssetParams: AssetParams,
+    EllipticCurve: EllipticCurve,
+    GITxn: GITxn,
+    GTxn: GTxn,
+    Global: Global,
+    ITxn: ITxn,
+    ITxnCreate: ITxnCreate,
+    JsonRef: JsonRef,
+    Scratch: Scratch,
+    Txn: Txn,
+    addw: addw,
+    balance: balance,
+    base64Decode: base64Decode,
+    bitLength: bitLength,
+    bsqrt: bsqrt,
+    btoi: btoi,
+    bzero: bzero,
+    concat: concat,
+    divmodw: divmodw,
+    divw: divw,
+    ecdsaPkDecompress: ecdsaPkDecompress,
+    ecdsaPkRecover: ecdsaPkRecover,
+    ecdsaVerify: ecdsaVerify,
+    ed25519verify: ed25519verify,
+    ed25519verifyBare: ed25519verifyBare,
+    exp: exp,
+    expw: expw,
+    extract: extract,
+    extractUint16: extractUint16,
+    extractUint32: extractUint32,
+    extractUint64: extractUint64,
+    gaid: gaid,
+    getBit: getBit,
+    getByte: getByte,
+    itob: itob,
+    keccak256: keccak256,
+    minBalance: minBalance,
+    mulw: mulw,
+    replace: replace,
+    select: select,
+    setBit: setBit,
+    setByte: setByte,
+    sha256: sha256,
+    sha3_256: sha3_256,
+    sha512_256: sha512_256,
+    shl: shl,
+    shr: shr,
+    sqrt: sqrt,
+    substring: substring,
+    vrfVerify: vrfVerify
+});
+
+class ApplicationData {
+    application;
+    isCreating = false;
+    get appLogs() {
+        return this.application.appLogs;
+    }
+    constructor() {
+        this.application = {
+            approvalProgram: ALWAYS_APPROVE_TEAL_PROGRAM,
+            clearStateProgram: ALWAYS_APPROVE_TEAL_PROGRAM,
+            globalNumUint: 0,
+            globalNumBytes: 0,
+            localNumUint: 0,
+            localNumBytes: 0,
+            extraProgramPages: 0,
+            creator: lazyContext.defaultSender,
+            appLogs: [],
+        };
+    }
+}
+class ApplicationCls {
+    id;
+    constructor(id) {
+        this.id = asUint64(id ?? 0);
+    }
+    get data() {
+        return lazyContext.getApplicationData(this.id);
+    }
+    get approvalProgram() {
+        return this.data.application.approvalProgram;
+    }
+    get clearStateProgram() {
+        return this.data.application.clearStateProgram;
+    }
+    get globalNumUint() {
+        return this.data.application.globalNumUint;
+    }
+    get globalNumBytes() {
+        return this.data.application.globalNumBytes;
+    }
+    get localNumUint() {
+        return this.data.application.localNumUint;
+    }
+    get localNumBytes() {
+        return this.data.application.localNumBytes;
+    }
+    get extraProgramPages() {
+        return this.data.application.extraProgramPages;
+    }
+    get creator() {
+        return this.data.application.creator;
+    }
+    get address() {
+        const addr = algosdk.getApplicationAddress(asBigInt(this.id));
+        return Account(Bytes(addr));
+    }
+}
+
+class AssetCls {
+    id;
+    constructor(id) {
+        this.id = asUint64(id ?? 0);
+    }
+    get data() {
+        return lazyContext.getAssetData(this.id);
+    }
+    get total() {
+        return this.data.total;
+    }
+    get decimals() {
+        return this.data.decimals;
+    }
+    get defaultFrozen() {
+        return this.data.defaultFrozen;
+    }
+    get unitName() {
+        return this.data.unitName;
+    }
+    get name() {
+        return this.data.name;
+    }
+    get url() {
+        return this.data.url;
+    }
+    get metadataHash() {
+        return this.data.metadataHash;
+    }
+    get manager() {
+        return this.data.manager;
+    }
+    get reserve() {
+        return this.data.reserve;
+    }
+    get freeze() {
+        return this.data.freeze;
+    }
+    get clawback() {
+        return this.data.clawback;
+    }
+    get creator() {
+        return this.data.creator;
+    }
+    balance(account) {
+        return this.getAssetHolding(account).balance;
+    }
+    frozen(account) {
+        return this.getAssetHolding(account).frozen;
+    }
+    getAssetHolding(account) {
+        const accountData = lazyContext.getAccountData(account.bytes);
+        if (!accountData.optedAssets.has(asBigInt(this.id))) {
+            internal.errors.internalError('The asset is not opted into the account! Use `ctx.any.account(opted_asset_balances={{ASSET_ID: VALUE}})` to set emulated opted asset into the account.');
+        }
+        return accountData.optedAssets.get(asBigInt(this.id));
+    }
+}
+
+class AssetHolding {
+    balance;
+    frozen;
+    constructor(balance, frozen) {
+        this.balance = asUint64(balance);
+        this.frozen = frozen;
+    }
+}
+class AccountData {
+    optedAssets = new Map();
+    optedApplications = new Map();
+    account;
+    constructor() {
+        this.account = {
+            totalAppsCreated: 0,
+            totalAppsOptedIn: 0,
+            totalAssets: 0,
+            totalAssetsCreated: 0,
+            totalBoxBytes: 0,
+            totalBoxes: 0,
+            totalExtraAppPages: 0,
+            totalNumByteSlice: 0,
+            totalNumUint: 0,
+            minBalance: DEFAULT_ACCOUNT_MIN_BALANCE,
+            balance: 0,
+            authAddress: Account(),
+        };
+    }
+}
+class AccountCls {
+    bytes;
+    constructor(address) {
+        this.bytes = asBytes(address ?? ZERO_ADDRESS);
+    }
+    get data() {
+        return lazyContext.getAccountData(this.bytes);
+    }
+    get balance() {
+        return this.data.account.balance;
+    }
+    get minBalance() {
+        return this.data.account.minBalance;
+    }
+    get authAddress() {
+        return this.data.account.authAddress;
+    }
+    get totalNumUint() {
+        return this.data.account.totalNumUint;
+    }
+    get totalNumByteSlice() {
+        return this.data.account.totalNumByteSlice;
+    }
+    get totalExtraAppPages() {
+        return this.data.account.totalExtraAppPages;
+    }
+    get totalAppsCreated() {
+        return this.data.account.totalAppsCreated;
+    }
+    get totalAppsOptedIn() {
+        return this.data.account.totalAppsOptedIn;
+    }
+    get totalAssetsCreated() {
+        return this.data.account.totalAssetsCreated;
+    }
+    get totalAssets() {
+        return this.data.account.totalAssets;
+    }
+    get totalBoxes() {
+        return this.data.account.totalBoxes;
+    }
+    get totalBoxBytes() {
+        return this.data.account.totalBoxBytes;
+    }
+    isOptedIn(assetOrApp) {
+        if (assetOrApp instanceof AssetCls) {
+            return this.data.optedAssets.has(asUint64Cls(assetOrApp.id).asBigInt());
+        }
+        if (assetOrApp instanceof ApplicationCls) {
+            return this.data.optedApplications.has(asUint64Cls(assetOrApp.id).asBigInt());
+        }
+        throw new internal.errors.InternalError('Invalid argument type. Must be an `algopy.Asset` or `algopy.Application` instance.');
+    }
+}
+
+const baseDefaultFields = () => ({
+    sender: lazyContext.defaultSender,
+    fee: Uint64(0),
+    firstValid: Uint64(0),
+    firstValidTime: Uint64(0),
+    lastValid: Uint64(0),
+    note: Bytes(),
+    lease: Bytes(),
+    groupIndex: Uint64(0),
+    txnId: getRandomBytes(32).asAlgoTs(),
+    rekeyTo: Account(),
+});
+class TransactionBase {
+    constructor(fields) {
+        const baseDefaults = baseDefaultFields();
+        this.sender = fields.sender ?? baseDefaults.sender;
+        this.fee = fields.fee ?? baseDefaults.fee;
+        this.firstValid = fields.firstValid ?? baseDefaults.firstValid;
+        this.firstValidTime = fields.firstValidTime ?? baseDefaults.firstValidTime;
+        this.lastValid = fields.lastValid ?? baseDefaults.lastValid;
+        this.note = fields.note ?? baseDefaults.note;
+        this.lease = fields.lease ?? baseDefaults.lease;
+        this.groupIndex = fields.groupIndex ?? baseDefaults.groupIndex;
+        this.txnId = fields.txnId ?? baseDefaults.txnId;
+        this.rekeyTo = fields.rekeyTo ?? baseDefaults.rekeyTo;
+        this.scratchSpace = Array(256).fill(Uint64(0));
+    }
+    sender;
+    fee;
+    firstValid;
+    firstValidTime;
+    lastValid;
+    note;
+    lease;
+    groupIndex;
+    txnId;
+    rekeyTo;
+    scratchSpace;
+    setScratchSlot(index, value) {
+        const i = asNumber(index);
+        if (i >= this.scratchSpace.length) {
+            throw internal.errors.internalError('invalid scratch slot');
+        }
+        const bytesValue = asMaybeBytesCls(value);
+        const uint64Value = asMaybeUint64Cls(value);
+        this.scratchSpace[i] = bytesValue?.asAlgoTs() ?? uint64Value?.asAlgoTs() ?? Uint64(0);
+    }
+    getScratchSlot(index) {
+        const i = asNumber(index);
+        if (i >= this.scratchSpace.length) {
+            throw internal.errors.internalError('invalid scratch slot');
+        }
+        return this.scratchSpace[i];
+    }
+}
+class PaymentTransaction extends TransactionBase {
+    /* @internal */
+    static create(fields) {
+        return new PaymentTransaction(fields);
+    }
+    constructor(fields) {
+        super(fields);
+        this.receiver = fields.receiver ?? Account();
+        this.amount = fields.amount ?? Uint64(0);
+        this.closeRemainderTo = fields.closeRemainderTo ?? Account();
+    }
+    receiver;
+    amount;
+    closeRemainderTo;
+    type = TransactionType.Payment;
+    typeBytes = asUint64Cls(TransactionType.Payment).toBytes().asAlgoTs();
+}
+class KeyRegistrationTransaction extends TransactionBase {
+    /* @internal */
+    static create(fields) {
+        return new KeyRegistrationTransaction(fields);
+    }
+    constructor(fields) {
+        super(fields);
+        this.voteKey = fields.voteKey ?? Bytes();
+        this.selectionKey = fields.selectionKey ?? Bytes();
+        this.voteFirst = fields.voteFirst ?? Uint64(0);
+        this.voteLast = fields.voteLast ?? Uint64(0);
+        this.voteKeyDilution = fields.voteKeyDilution ?? Uint64(0);
+        this.nonparticipation = fields.nonparticipation ?? false;
+        this.stateProofKey = fields.stateProofKey ?? Bytes();
+    }
+    voteKey;
+    selectionKey;
+    voteFirst;
+    voteLast;
+    voteKeyDilution;
+    nonparticipation;
+    stateProofKey;
+    type = TransactionType.KeyRegistration;
+    typeBytes = asUint64Cls(TransactionType.KeyRegistration).toBytes().asAlgoTs();
+}
+class AssetConfigTransaction extends TransactionBase {
+    /* @internal */
+    static create(fields) {
+        return new AssetConfigTransaction(fields);
+    }
+    constructor(fields) {
+        super(fields);
+        this.configAsset = fields.configAsset ?? Asset();
+        this.total = fields.total ?? Uint64(0);
+        this.decimals = fields.decimals ?? Uint64(0);
+        this.defaultFrozen = fields.defaultFrozen ?? false;
+        this.unitName = fields.unitName ?? Bytes();
+        this.assetName = fields.assetName ?? Bytes();
+        this.url = fields.url ?? Bytes();
+        this.metadataHash = fields.metadataHash ?? Bytes();
+        this.manager = fields.manager ?? Account();
+        this.reserve = fields.reserve ?? Account();
+        this.freeze = fields.freeze ?? Account();
+        this.clawback = fields.clawback ?? Account();
+        this.createdAsset = fields.createdAsset ?? Asset();
+    }
+    configAsset;
+    total;
+    decimals;
+    defaultFrozen;
+    unitName;
+    assetName;
+    url;
+    metadataHash;
+    manager;
+    reserve;
+    freeze;
+    clawback;
+    createdAsset;
+    type = TransactionType.AssetConfig;
+    typeBytes = asUint64Cls(TransactionType.AssetConfig).toBytes().asAlgoTs();
+}
+class AssetTransferTransaction extends TransactionBase {
+    /* @internal */
+    static create(fields) {
+        return new AssetTransferTransaction(fields);
+    }
+    constructor(fields) {
+        super(fields);
+        this.xferAsset = fields.xferAsset ?? Asset();
+        this.assetAmount = fields.assetAmount ?? Uint64(0);
+        this.assetSender = fields.assetSender ?? Account();
+        this.assetReceiver = fields.assetReceiver ?? Account();
+        this.assetCloseTo = fields.assetCloseTo ?? Account();
+    }
+    xferAsset;
+    assetAmount;
+    assetSender;
+    assetReceiver;
+    assetCloseTo;
+    type = TransactionType.AssetTransfer;
+    typeBytes = asUint64Cls(TransactionType.AssetTransfer).toBytes().asAlgoTs();
+}
+class AssetFreezeTransaction extends TransactionBase {
+    /* @internal */
+    static create(fields) {
+        return new AssetFreezeTransaction(fields);
+    }
+    constructor(fields) {
+        super(fields);
+        this.freezeAsset = fields.freezeAsset ?? Asset();
+        this.freezeAccount = fields.freezeAccount ?? Account();
+        this.frozen = fields.frozen ?? false;
+    }
+    freezeAsset;
+    freezeAccount;
+    frozen;
+    type = TransactionType.AssetFreeze;
+    typeBytes = asUint64Cls(TransactionType.AssetFreeze).toBytes().asAlgoTs();
+}
+class ApplicationTransaction extends TransactionBase {
+    /* @internal */
+    static create(fields) {
+        return new ApplicationTransaction(fields);
+    }
+    #appArgs;
+    #accounts;
+    #assets;
+    #apps;
+    #approvalProgramPages;
+    #clearStateProgramPages;
+    #appLogs;
+    constructor(fields) {
+        super(fields);
+        this.appId = fields.appId ?? Application();
+        this.onCompletion = fields.onCompletion ?? 'NoOp';
+        this.globalNumUint = fields.globalNumUint ?? Uint64(0);
+        this.globalNumBytes = fields.globalNumBytes ?? Uint64(0);
+        this.localNumUint = fields.localNumUint ?? Uint64(0);
+        this.localNumBytes = fields.localNumBytes ?? Uint64(0);
+        this.extraProgramPages = fields.extraProgramPages ?? Uint64(0);
+        this.createdApp = fields.createdApp ?? Application();
+        this.#appArgs = fields.appArgs ?? [];
+        this.#appLogs = fields.appLogs ?? [];
+        this.#accounts = fields.accounts ?? [];
+        this.#assets = fields.assets ?? [];
+        this.#apps = fields.apps ?? [];
+        this.#approvalProgramPages = fields.approvalProgramPages ?? (fields.approvalProgram ? [fields.approvalProgram] : []);
+        this.#clearStateProgramPages = fields.clearStateProgramPages ?? (fields.clearStateProgram ? [fields.clearStateProgram] : []);
+        fields.scratchSpace?.forEach((v, i) => this.setScratchSlot(i, v));
+    }
+    appId;
+    onCompletion;
+    globalNumUint;
+    globalNumBytes;
+    localNumUint;
+    localNumBytes;
+    extraProgramPages;
+    createdApp;
+    get approvalProgram() {
+        return this.approvalProgramPages(0);
+    }
+    get clearStateProgram() {
+        return this.clearStateProgramPages(0);
+    }
+    get numAppArgs() {
+        return Uint64(this.#appArgs.length);
+    }
+    get numAccounts() {
+        return Uint64(this.#accounts.length);
+    }
+    get numAssets() {
+        return Uint64(this.#assets.length);
+    }
+    get numApps() {
+        return Uint64(this.#apps.length);
+    }
+    get numApprovalProgramPages() {
+        return Uint64(this.approvalProgramPages.length);
+    }
+    get numClearStateProgramPages() {
+        return Uint64(this.clearStateProgramPages.length);
+    }
+    get numLogs() {
+        return Uint64(this.#appLogs.length || lazyContext.getApplicationData(this.appId.id).appLogs.length);
+    }
+    get lastLog() {
+        return this.#appLogs.at(-1) ?? lazyContext.getApplicationData(this.appId.id).appLogs.at(-1) ?? Bytes();
+    }
+    appArgs(index) {
+        return this.#appArgs[asNumber(index)];
+    }
+    accounts(index) {
+        return this.#accounts[asNumber(index)];
+    }
+    assets(index) {
+        return this.#assets[asNumber(index)];
+    }
+    apps(index) {
+        return this.#apps[asNumber(index)];
+    }
+    approvalProgramPages(index) {
+        return combineIntoMaxBytePages(this.#approvalProgramPages)[asNumber(index)];
+    }
+    clearStateProgramPages(index) {
+        return combineIntoMaxBytePages(this.#clearStateProgramPages)[asNumber(index)];
+    }
+    logs(index) {
+        const i = asNumber(index);
+        return this.#appLogs[i] ?? lazyContext.getApplicationData(this.appId.id).appLogs ?? Bytes();
+    }
+    type = TransactionType.ApplicationCall;
+    typeBytes = asUint64Cls(TransactionType.ApplicationCall).toBytes().asAlgoTs();
+    /* @internal */
+    get appLogs() {
+        return this.#appLogs;
+    }
+    /* @internal */
+    appendLog(value) {
+        if (this.#appLogs.length + 1 > MAX_ITEMS_IN_LOG) {
+            throw internal.errors.internalError(`Too many log calls in program, up to ${MAX_ITEMS_IN_LOG} is allowed`);
+        }
+        this.#appLogs.push(asBytes(value));
+    }
+}
+
+const isUint64GenericType = (typeName) => {
+    if (typeName === undefined)
+        return false;
+    const genericTypes = extractGenericTypeArgs(typeName);
+    return genericTypes.some((t) => t.toLocaleLowerCase() === 'uint64');
+};
+const extractStates = (contract) => {
+    const stateTotals = { globalNumBytes: 0, globalNumUint: 0, localNumBytes: 0, localNumUint: 0 };
+    const states = {
+        globalStates: new Map(),
+        localStates: new Map(),
+        totals: stateTotals,
+    };
+    Object.entries(contract).forEach(([key, value]) => {
+        const isLocalState = value instanceof Function && value.name === 'localStateInternal';
+        const isGlobalState = value instanceof internal.state.GlobalStateCls;
+        if (isLocalState || isGlobalState) {
+            // set key using property name if not already set
+            if (value.key === undefined)
+                value.key = Bytes(key);
+            // capture state into the context
+            if (isLocalState)
+                states.localStates.set(value.key, value.map);
+            else
+                states.globalStates.set(value.key, value);
+            // populate state totals
+            const isUint64State = isUint64GenericType(getGenericTypeInfo(value));
+            stateTotals.globalNumUint += isGlobalState && isUint64State ? 1 : 0;
+            stateTotals.globalNumBytes += isGlobalState && !isUint64State ? 1 : 0;
+            stateTotals.localNumUint += isLocalState && isUint64State ? 1 : 0;
+            stateTotals.localNumBytes += isLocalState && !isUint64State ? 1 : 0;
+        }
+    });
+    return states;
+};
+const extractArraysFromArgs = (args) => {
+    const transactions = [];
+    const accounts = [];
+    const apps = [];
+    const assets = [];
+    for (const arg of args) {
+        if (isTransaction(arg)) {
+            transactions.push(arg);
+        }
+        else if (arg instanceof AccountCls) {
+            accounts.push(arg);
+        }
+        else if (arg instanceof ApplicationCls) {
+            apps.push(arg);
+        }
+        else if (arg instanceof AssetCls) {
+            assets.push(arg);
+        }
+    }
+    return { accounts, apps, assets, transactions };
+};
+function isTransaction(obj) {
+    return (obj instanceof PaymentTransaction ||
+        obj instanceof KeyRegistrationTransaction ||
+        obj instanceof AssetConfigTransaction ||
+        obj instanceof AssetTransferTransaction ||
+        obj instanceof AssetFreezeTransaction ||
+        obj instanceof ApplicationTransaction);
+}
+class ContractContext {
+    create(type, ...args) {
+        const proxy = new Proxy(type, this.getContractProxyHandler());
+        return new proxy(...args);
+    }
+    getContractProxyHandler() {
+        const onConstructed = (instance) => {
+            const states = extractStates(instance);
+            const application = lazyContext.any.application({
+                ...states.totals,
+            });
+            lazyContext.ledger.addAppIdContractMap(application.id, instance);
+        };
+        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') {
+                            return (...args) => {
+                                const app = lazyContext.ledger.getApplicationForContract(receiver);
+                                const { transactions, ...appCallArgs } = extractArraysFromArgs(args);
+                                const abiMetadata = getAbiMetadata(receiver, prop);
+                                const txns = [
+                                    ...(transactions ?? []),
+                                    lazyContext.any.txn.applicationCall({
+                                        appId: app,
+                                        ...appCallArgs,
+                                        onCompletion: (abiMetadata?.allowActions ?? [])[0],
+                                    }),
+                                ];
+                                return lazyContext.txn.ensureScope(txns).execute(() => orig.apply(target, args));
+                            };
+                        }
+                        return orig;
+                    },
+                });
+                onConstructed(instance);
+                isArc4 = hasAbiMetadata(instance);
+                return instance;
+            },
+        };
+    }
+}
+
+class LedgerContext {
+    appIdIter = iterBigInt(1001n, MAX_UINT64);
+    assetIdIter = iterBigInt(1001n, MAX_UINT64);
+    applicationDataMap = new Map();
+    appIdContractMap = new Map();
+    accountDataMap = new Map();
+    assetDataMap = new Map();
+    globalData = new GlobalData();
+    addAppIdContractMap(appId, contract) {
+        this.appIdContractMap.set(asBigInt(appId), contract);
+    }
+    getAsset(assetId) {
+        const id = asBigInt(assetId);
+        if (this.assetDataMap.has(id)) {
+            return Asset(asUint64(id));
+        }
+        throw internal.errors.internalError('Unknown asset, check correct testing context is active');
+    }
+    getApplication(applicationId) {
+        const id = asBigInt(applicationId);
+        if (this.applicationDataMap.has(id)) {
+            return Application(asUint64(id));
+        }
+        throw internal.errors.internalError('Unknown application, check correct testing context is active');
+    }
+    getApplicationForContract(contract) {
+        for (const [appId, c] of this.appIdContractMap) {
+            if (c === contract) {
+                if (this.applicationDataMap.has(appId)) {
+                    return Application(asUint64(appId));
+                }
+            }
+        }
+        throw internal.errors.internalError('Unknown contract, check correct testing context is active');
+    }
+    /**
+     * Update asset holdings for account, only specified values will be updated.
+     * Account will also be opted-in to asset
+     * @param accountAddress
+     * @param assetId
+     * @param balance
+     * @param frozen
+     */
+    updateAssetHolding(accountAddress, assetId, balance, frozen) {
+        const addr = (asMaybeBytesCls(accountAddress) ?? asBytesCls(accountAddress.bytes)).toString();
+        const id = (asMaybeUint64Cls(assetId) ?? asUint64Cls(assetId.id)).asBigInt();
+        const accountData = this.accountDataMap.get(addr);
+        const asset = this.assetDataMap.get(id);
+        const holding = accountData.optedAssets.get(id) ?? new AssetHolding(0n, asset.defaultFrozen);
+        if (balance !== undefined)
+            holding.balance = asUint64(balance);
+        if (frozen !== undefined)
+            holding.frozen = frozen;
+        accountData.optedAssets.set(id, holding);
+    }
+    patchGlobalData(data) {
+        this.globalData = {
+            ...this.globalData,
+            ...data,
+        };
+    }
+}
+
+function decodeLogs(logs, decoding) {
+    return logs.map((log, i) => {
+        switch (decoding[i]) {
+            case 'i':
+                return internal.encodingUtil.uint8ArrayToBigInt(log);
+            case 's':
+                return internal.encodingUtil.uint8ArrayToUtf8(log);
+            default:
+                return log;
+        }
+    });
+}
+
+const mapCommonFields = (fields) => {
+    const { sender, note, rekeyTo, ...rest } = fields;
+    return {
+        sender: sender instanceof Account ? sender : typeof sender === 'string' ? Account(asBytes(sender)) : lazyContext.activeApplication.address,
+        note: note !== undefined ? asBytes(note) : undefined,
+        rekeyTo: rekeyTo instanceof Account ? rekeyTo : typeof rekeyTo === 'string' ? Account(asBytes(rekeyTo)) : undefined,
+        ...rest,
+    };
+};
+class PaymentInnerTxn extends PaymentTransaction {
+    isItxn;
+    /* @internal */
+    static create(fields) {
+        return new PaymentInnerTxn(fields);
+    }
+    /* @internal */
+    constructor(fields) {
+        super(mapCommonFields(fields));
+    }
+}
+class KeyRegistrationInnerTxn extends KeyRegistrationTransaction {
+    isItxn;
+    /* @internal */
+    static create(fields) {
+        return new KeyRegistrationInnerTxn(fields);
+    }
+    /* @internal */
+    constructor(fields) {
+        super(mapCommonFields(fields));
+    }
+}
+class AssetConfigInnerTxn extends AssetConfigTransaction {
+    isItxn;
+    /* @internal */
+    static create(fields) {
+        return new AssetConfigInnerTxn(fields);
+    }
+    /* @internal */
+    constructor(fields) {
+        const { assetName, unitName, url, ...rest } = mapCommonFields(fields);
+        const createdAsset = lazyContext.any.asset({
+            name: typeof assetName === 'string' ? asBytes(assetName) : assetName,
+            unitName: typeof unitName === 'string' ? asBytes(unitName) : unitName,
+            url: typeof url === 'string' ? asBytes(url) : url,
+            ...rest,
+        });
+        super({
+            assetName: typeof assetName === 'string' ? asBytes(assetName) : assetName,
+            unitName: typeof unitName === 'string' ? asBytes(unitName) : unitName,
+            url: typeof url === 'string' ? asBytes(url) : url,
+            ...rest,
+            createdAsset: createdAsset,
+        });
+    }
+}
+class AssetTransferInnerTxn extends AssetTransferTransaction {
+    isItxn;
+    /* @internal */
+    static create(fields) {
+        if (fields.xferAsset === undefined) {
+            throw new Error('xferAsset is required');
+        }
+        return new AssetTransferInnerTxn(fields);
+    }
+    /* @internal */
+    constructor(fields) {
+        super(mapCommonFields(fields));
+    }
+}
+class AssetFreezeInnerTxn extends AssetFreezeTransaction {
+    isItxn;
+    /* @internal */
+    static create(fields) {
+        if (fields.freezeAsset === undefined) {
+            throw new Error('freezeAsset is required');
+        }
+        return new AssetFreezeInnerTxn(fields);
+    }
+    /* @internal */
+    constructor(fields) {
+        const { freezeAsset, freezeAccount, ...rest } = mapCommonFields(fields);
+        const asset = freezeAsset instanceof internal.primitives.Uint64Cls ? getAsset(freezeAsset) : freezeAsset;
+        const account = typeof freezeAccount === 'string' ? Account(asBytes(freezeAccount)) : freezeAccount;
+        super({
+            freezeAsset: asset,
+            freezeAccount: account,
+            ...rest,
+        });
+    }
+}
+class ApplicationInnerTxn extends ApplicationTransaction {
+    isItxn;
+    /* @internal */
+    static create(fields) {
+        return new ApplicationInnerTxn(fields);
+    }
+    /* @internal */
+    constructor(fields) {
+        const { appId, approvalProgram, clearStateProgram, onCompletion, appArgs, accounts, assets, apps, ...rest } = mapCommonFields(fields);
+        super({
+            appId: appId instanceof internal.primitives.Uint64Cls ? getApp(appId) : appId,
+            onCompletion: typeof onCompletion === 'string'
+                ? onCompletion
+                : onCompletion !== undefined
+                    ? arc4.OnCompleteAction[onCompletion]
+                    : undefined,
+            approvalProgram: Array.isArray(approvalProgram) ? undefined : approvalProgram,
+            approvalProgramPages: Array.isArray(approvalProgram) ? approvalProgram : undefined,
+            clearStateProgram: Array.isArray(clearStateProgram) ? undefined : clearStateProgram,
+            clearStateProgramPages: Array.isArray(clearStateProgram) ? clearStateProgram : undefined,
+            appArgs: appArgs?.map((x) => toBytes(x)),
+            accounts: accounts?.map((x) => x),
+            assets: assets?.map((x) => x),
+            apps: apps?.map((x) => x),
+            ...rest,
+        });
+    }
+}
+const createInnerTxn = (fields) => {
+    switch (fields.type) {
+        case TransactionType.Payment:
+            return new PaymentInnerTxn(fields);
+        case TransactionType.AssetConfig:
+            return new AssetConfigInnerTxn(fields);
+        case TransactionType.AssetTransfer:
+            return new AssetTransferInnerTxn(fields);
+        case TransactionType.AssetFreeze:
+            return new AssetFreezeInnerTxn(fields);
+        case TransactionType.ApplicationCall:
+            return new ApplicationInnerTxn(fields);
+        case TransactionType.KeyRegistration:
+            return new KeyRegistrationInnerTxn(fields);
+        default:
+            throw new internal.errors.InternalError(`Invalid inner transaction type: ${fields.type}`);
+    }
+};
+function submitGroup(...transactionFields) {
+    return transactionFields.map((f) => f.submit());
+}
+function payment(fields) {
+    ensureItxnGroupBegin();
+    return new ItxnParams(fields, TransactionType.Payment);
+}
+function keyRegistration(fields) {
+    ensureItxnGroupBegin();
+    return new ItxnParams(fields, TransactionType.KeyRegistration);
+}
+function assetConfig(fields) {
+    ensureItxnGroupBegin();
+    return new ItxnParams(fields, TransactionType.AssetConfig);
+}
+function assetTransfer(fields) {
+    ensureItxnGroupBegin();
+    return new ItxnParams(fields, TransactionType.AssetTransfer);
+}
+function assetFreeze(fields) {
+    ensureItxnGroupBegin();
+    return new ItxnParams(fields, TransactionType.AssetFreeze);
+}
+function applicationCall(fields) {
+    ensureItxnGroupBegin();
+    return new ItxnParams(fields, TransactionType.ApplicationCall);
+}
+class ItxnParams {
+    #fields;
+    constructor(fields, type) {
+        this.#fields = { ...fields, type };
+    }
+    submit() {
+        return createInnerTxn(this.#fields);
+    }
+    set(p) {
+        Object.assign(this.#fields, p);
+    }
+    copy() {
+        return new ItxnParams(this.#fields, this.#fields.type);
+    }
+}
+const ensureItxnGroupBegin = () => {
+    if (!lazyContext.activeGroup.constructingItxnGroup.length) {
+        lazyContext.activeGroup.beginInnerTransactionGroup();
+    }
+};
+
+function ScopeGenerator(dispose) {
+    function* internal() {
+        try {
+            yield;
+        }
+        finally {
+            dispose();
+        }
+    }
+    const scope = internal();
+    scope.next();
+    return {
+        done: () => {
+            scope.return();
+        },
+    };
+}
+class TransactionContext {
+    groups = [];
+    #activeGroup;
+    createScope(group, activeTransactionIndex) {
+        const transactionGroup = new TransactionGroup(group, activeTransactionIndex);
+        const previousGroup = this.#activeGroup;
+        this.#activeGroup = transactionGroup;
+        const scope = ScopeGenerator(() => {
+            if (this.#activeGroup?.transactions?.length) {
+                this.groups.push(this.#activeGroup);
+            }
+            this.#activeGroup = previousGroup;
+        });
+        return {
+            execute: (body) => {
+                const result = body();
+                scope.done();
+                return result;
+            },
+        };
+    }
+    ensureScope(group, activeTransactionIndex) {
+        if (!this.#activeGroup || !this.#activeGroup.transactions.length) {
+            return this.createScope(group, activeTransactionIndex);
+        }
+        return {
+            execute: (body) => {
+                return body();
+            },
+        };
+    }
+    get activeGroup() {
+        if (this.#activeGroup) {
+            return this.#activeGroup;
+        }
+        throw internal.errors.internalError('no active txn group');
+    }
+    get lastGroup() {
+        if (this.groups.length === 0) {
+            internal.errors.internalError('No group transactions found!');
+        }
+        return this.groups.at(-1);
+    }
+    get lastActive() {
+        return this.lastGroup.activeTransaction;
+    }
+    /* internal */
+    appendLog(value) {
+        const activeTransaction = this.activeGroup.activeTransaction;
+        if (activeTransaction.type !== TransactionType.ApplicationCall) {
+            throw internal.errors.internalError('Can only add logs to ApplicationCallTransaction!');
+        }
+        activeTransaction.appendLog(value);
+    }
+    exportLogs(appId, ...decoding) {
+        const transaction = this.groups
+            .flatMap((g) => g.transactions)
+            .filter((t) => t.type === TransactionType.ApplicationCall)
+            .find((t) => asBigInt(t.appId.id) === asBigInt(appId));
+        let logs = [];
+        if (transaction) {
+            logs = transaction.appLogs;
+        }
+        else {
+            logs = lazyContext.getApplicationData(appId).appLogs;
+        }
+        const rawLogs = logs.map((l) => internal.primitives.toExternalValue(l));
+        return decodeLogs(rawLogs, decoding);
+    }
+}
+class TransactionGroup {
+    activeTransactionIndex;
+    latestTimestamp;
+    transactions;
+    itxnGroups = [];
+    constructingItxnGroup = [];
+    constructor(transactions, activeTransactionIndex) {
+        this.latestTimestamp = Date.now();
+        if (transactions.length > algosdk.AtomicTransactionComposer.MAX_GROUP_SIZE) {
+            internal.errors.internalError(`Transaction group can have at most ${algosdk.AtomicTransactionComposer.MAX_GROUP_SIZE} transactions, as per AVM limits.`);
+        }
+        transactions.forEach((txn, index) => Object.assign(txn, { groupIndex: asUint64(index) }));
+        this.activeTransactionIndex = activeTransactionIndex === undefined ? transactions.length - 1 : activeTransactionIndex;
+        this.transactions = transactions;
+    }
+    get activeTransaction() {
+        return this.transactions[this.activeTransactionIndex];
+    }
+    get activeApplicationId() {
+        if (this.transactions.length === 0) {
+            internal.errors.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;
+    }
+    get constructingItxn() {
+        if (!this.constructingItxnGroup.length) {
+            internal.errors.internalError('itxn field without itxn begin');
+        }
+        return this.constructingItxnGroup.at(-1);
+    }
+    getScratchSlot(index) {
+        return this.activeTransaction.getScratchSlot(index);
+    }
+    patchActiveTransactionFields(fields) {
+        const activeTransaction = this.activeTransaction;
+        const filteredFields = Object.fromEntries(Object.entries(fields).filter(([_, value]) => value !== undefined));
+        Object.assign(activeTransaction, filteredFields);
+    }
+    beginInnerTransactionGroup() {
+        if (this.constructingItxnGroup.length) {
+            internal.errors.internalError('itxn begin without itxn submit');
+        }
+        testInvariant(this.activeTransaction.type === TransactionType.ApplicationCall, 'No active application call transaction');
+        if (this.activeTransaction.onCompletion === 'ClearState') {
+            internal.errors.internalError('Cannot begin inner transaction group in a clear state call');
+        }
+        this.constructingItxnGroup.push({});
+    }
+    appendInnerTransactionGroup() {
+        if (!this.constructingItxnGroup.length) {
+            internal.errors.internalError('itxn next without itxn begin');
+        }
+        this.constructingItxnGroup.push({ type: TransactionType.Payment });
+    }
+    submitInnerTransactionGroup() {
+        if (!this.constructingItxnGroup.length) {
+            internal.errors.internalError('itxn submit without itxn begin');
+        }
+        if (this.constructingItxnGroup.length > algosdk.AtomicTransactionComposer.MAX_GROUP_SIZE) {
+            internal.errors.internalError('Cannot submit more than 16 inner transactions at once');
+        }
+        const itxns = this.constructingItxnGroup.map((t) => createInnerTxn(t));
+        itxns.forEach((itxn, index) => Object.assign(itxn, { groupIndex: asUint64(index) }));
+        this.itxnGroups.push(new ItxnGroup(itxns));
+        this.constructingItxnGroup = [];
+    }
+    getItxnGroup(index) {
+        const i = index !== undefined ? asNumber(index) : undefined;
+        testInvariant(this.itxnGroups.length > 0, 'no previous inner transactions');
+        if (i !== undefined && i >= this.itxnGroups.length) {
+            throw new internal.errors.InternalError('Invalid group index');
+        }
+        const group = i !== undefined ? this.itxnGroups[i] : this.itxnGroups.at(-1);
+        testInvariant(group.itxns.length > 0, 'no previous inner transactions');
+        return group;
+    }
+    getApplicationTransaction(index) {
+        return this.getTransactionImpl({ type: TransactionType.ApplicationCall, index });
+    }
+    getAssetConfigTransaction(index) {
+        return this.getTransactionImpl({ type: TransactionType.AssetConfig, index });
+    }
+    getAssetTransferTransaction(index) {
+        return this.getTransactionImpl({ type: TransactionType.AssetTransfer, index });
+    }
+    getAssetFreezeTransaction(index) {
+        return this.getTransactionImpl({ type: TransactionType.AssetFreeze, index });
+    }
+    getKeyRegistrationTransaction(index) {
+        return this.getTransactionImpl({ type: TransactionType.KeyRegistration, index });
+    }
+    getPaymentTransaction(index) {
+        return this.getTransactionImpl({ type: TransactionType.Payment, index });
+    }
+    getTransaction(index) {
+        return this.getTransactionImpl({ index });
+    }
+    getTransactionImpl({ type, index }) {
+        const i = index !== undefined ? asNumber(index) : undefined;
+        if (i !== undefined && i >= lazyContext.activeGroup.transactions.length) {
+            throw new internal.errors.InternalError('Invalid group index');
+        }
+        const transaction = i !== undefined ? lazyContext.activeGroup.transactions[i] : lazyContext.activeGroup.activeTransaction;
+        if (type === undefined) {
+            return transaction;
+        }
+        if (transaction.type !== type) {
+            throw new internal.errors.InternalError(`Invalid transaction type: ${transaction.type}`);
+        }
+        switch (type) {
+            case TransactionType.ApplicationCall:
+                return transaction;
+            case TransactionType.Payment:
+                return transaction;
+            case TransactionType.AssetConfig:
+                return transaction;
+            case TransactionType.AssetTransfer:
+                return transaction;
+            case TransactionType.AssetFreeze:
+                return transaction;
+            case TransactionType.KeyRegistration:
+                return transaction;
+            default:
+                throw new internal.errors.InternalError(`Invalid transaction type: ${type}`);
+        }
+    }
+}
+class ItxnGroup {
+    itxns = [];
+    constructor(itxns) {
+        this.itxns = itxns;
+    }
+    getApplicationInnerTxn(index) {
+        return this.getInnerTxnImpl({ type: TransactionType.ApplicationCall, index });
+    }
+    getAssetConfigInnerTxn(index) {
+        return this.getInnerTxnImpl({ type: TransactionType.AssetConfig, index });
+    }
+    getAssetTransferInnerTxn(index) {
+        return this.getInnerTxnImpl({ type: TransactionType.AssetTransfer, index });
+    }
+    getAssetFreezeInnerTxn(index) {
+        return this.getInnerTxnImpl({ type: TransactionType.AssetFreeze, index });
+    }
+    getKeyRegistrationInnerTxn(index) {
+        return this.getInnerTxnImpl({ type: TransactionType.KeyRegistration, index });
+    }
+    getPaymentInnerTxn(index) {
+        return this.getInnerTxnImpl({ type: TransactionType.Payment, index });
+    }
+    getInnerTxn(index) {
+        return this.getInnerTxnImpl({ index });
+    }
+    getInnerTxnImpl({ type, index }) {
+        testInvariant(this.itxns.length > 0, 'no previous inner transactions');
+        const i = index !== undefined ? asNumber(index) : undefined;
+        if (i !== undefined && i >= this.itxns.length) {
+            throw new internal.errors.InternalError('Invalid group index');
+        }
+        const transaction = i !== undefined ? this.itxns[i] : this.itxns.at(-1);
+        if (type === undefined) {
+            return transaction;
+        }
+        if (transaction.type !== type) {
+            throw new internal.errors.InternalError(`Invalid transaction type: ${transaction.type}`);
+        }
+        switch (type) {
+            case TransactionType.ApplicationCall:
+                return transaction;
+            case TransactionType.Payment:
+                return transaction;
+            case TransactionType.AssetConfig:
+                return transaction;
+            case TransactionType.AssetTransfer:
+                return transaction;
+            case TransactionType.AssetFreeze:
+                return transaction;
+            case TransactionType.KeyRegistration:
+                return transaction;
+            default:
+                throw new internal.errors.InternalError(`Invalid transaction type: ${type}`);
+        }
+    }
+}
+
+class AvmValueGenerator {
+    uint64(minValue = 0n, maxValue = MAX_UINT64) {
+        if (maxValue > MAX_UINT64) {
+            internal.errors.internalError('maxValue must be less than or equal to MAX_UINT64');
+        }
+        if (minValue > maxValue) {
+            internal.errors.internalError('minValue must be less than or equal to maxValue');
+        }
+        if (minValue < 0n || maxValue < 0n) {
+            internal.errors.internalError('minValue and maxValue must be greater than or equal to 0');
+        }
+        return Uint64(getRandomBigInt(minValue, maxValue));
+    }
+    bytes(length = MAX_BYTES_SIZE) {
+        return Bytes(new Uint8Array(randomBytes(length)));
+    }
+    account(input) {
+        const addr = input?.address ? asBytesCls(input.address).toString() : undefined;
+        if (addr && lazyContext.ledger.accountDataMap.has(addr)) {
+            internal.errors.internalError('Account with such address already exists in testing context. Use `context.ledger.getAccount(address)` to retrieve the existing account.');
+        }
+        const accountAddress = addr ?? algosdk.generateAccount().addr;
+        const data = new AccountData();
+        const { address, optedAssetBalances, optedApplications, ...account } = input ?? {};
+        data.account = {
+            ...data.account,
+            ...account,
+        };
+        lazyContext.ledger.accountDataMap.set(accountAddress, data);
+        if (input?.optedAssetBalances) {
+            for (const [assetId, balance] of input.optedAssetBalances) {
+                lazyContext.ledger.updateAssetHolding(accountAddress, assetId, balance);
+            }
+        }
+        if (input?.optedApplications) {
+            for (const app of input.optedApplications) {
+                data.optedApplications.set(asBigInt(app.id), app);
+            }
+        }
+        return new AccountCls(Bytes(accountAddress));
+    }
+    asset(input) {
+        const id = input?.assetId;
+        if (id && lazyContext.ledger.assetDataMap.has(asBigInt(id))) {
+            internal.errors.internalError('Asset with such ID already exists in testing context!');
+        }
+        const assetId = asUint64Cls(id ?? lazyContext.ledger.assetIdIter.next().value);
+        const defaultAssetData = {
+            total: lazyContext.any.uint64(),
+            decimals: lazyContext.any.uint64(1, 6),
+            defaultFrozen: false,
+            unitName: lazyContext.any.bytes(4),
+            name: lazyContext.any.bytes(32),
+            url: lazyContext.any.bytes(10),
+            metadataHash: lazyContext.any.bytes(32),
+            manager: Account(ZERO_ADDRESS),
+            freeze: Account(ZERO_ADDRESS),
+            clawback: Account(ZERO_ADDRESS),
+            creator: lazyContext.defaultSender,
+            reserve: Account(ZERO_ADDRESS),
+        };
+        const { assetId: _, ...assetData } = input ?? {};
+        lazyContext.ledger.assetDataMap.set(assetId.asBigInt(), {
+            ...defaultAssetData,
+            ...assetData,
+        });
+        return new AssetCls(assetId.asAlgoTs());
+    }
+    application(input) {
+        const id = input?.applicationId;
+        if (id && lazyContext.ledger.applicationDataMap.has(asBigInt(id))) {
+            internal.errors.internalError('Application with such ID already exists in testing context!');
+        }
+        const applicationId = asUint64Cls(id ?? lazyContext.ledger.appIdIter.next().value);
+        const data = new ApplicationData();
+        const { applicationId: _, ...applicationData } = input ?? {};
+        data.application = {
+            ...data.application,
+            ...applicationData,
+        };
+        lazyContext.ledger.applicationDataMap.set(applicationId.asBigInt(), data);
+        return new ApplicationCls(applicationId.asAlgoTs());
+    }
+}
+
+class TxnValueGenerator {
+    applicationCall(fields) {
+        const params = fields ?? {};
+        if (params.appId && !lazyContext.ledger.applicationDataMap.has(asBigInt(params.appId.id))) {
+            internal.errors.internalError(`Application ID ${params.appId.id} not found in test context`);
+        }
+        if (!params.appId) {
+            params.appId = lazyContext.any.application();
+        }
+        return ApplicationTransaction.create(params);
+    }
+    payment(fields) {
+        return PaymentTransaction.create(fields ?? {});
+    }
+    keyRegistration(fields) {
+        return KeyRegistrationTransaction.create(fields ?? {});
+    }
+    assetConfig(fields) {
+        return AssetConfigTransaction.create(fields ?? {});
+    }
+    assetTransfer(fields) {
+        return AssetTransferTransaction.create(fields ?? {});
+    }
+    assetFreeze(fields) {
+        return AssetFreezeTransaction.create(fields ?? {});
+    }
+}
+
+class ValueGenerator extends AvmValueGenerator {
+    txn;
+    constructor() {
+        super();
+        this.txn = new TxnValueGenerator();
+    }
+}
+
+class TestExecutionContext {
+    #applicationLogs;
+    #contractContext;
+    #ledgerContext;
+    #txnContext;
+    #valueGenerator;
+    #defaultSender;
+    constructor() {
+        internal.ctxMgr.instance = this;
+        this.#applicationLogs = new Map();
+        this.#contractContext = new ContractContext();
+        this.#ledgerContext = new LedgerContext();
+        this.#txnContext = new TransactionContext();
+        this.#valueGenerator = new ValueGenerator();
+        this.#defaultSender = Account(Bytes(algosdk.generateAccount().addr));
+    }
+    account(address) {
+        return new AccountCls(address);
+    }
+    application(id) {
+        return new ApplicationCls(id);
+    }
+    asset(id) {
+        return new AssetCls(id);
+    }
+    log(value) {
+        this.txn.appendLog(value);
+    }
+    exportLogs(appId, ...decoding) {
+        return this.txn.exportLogs(appId, ...decoding);
+    }
+    get op() {
+        return ops;
+    }
+    get contract() {
+        return this.#contractContext;
+    }
+    get ledger() {
+        return this.#ledgerContext;
+    }
+    get txn() {
+        return this.#txnContext;
+    }
+    get any() {
+        return this.#valueGenerator;
+    }
+    get defaultSender() {
+        return this.#defaultSender;
+    }
+    get abiMetadata() {
+        return {
+            captureMethodConfig,
+        };
+    }
+    get gtxn() {
+        return {
+            Transaction: (index) => this.txn.activeGroup.getTransaction(index),
+            PaymentTxn: (index) => this.txn.activeGroup.getPaymentTransaction(index),
+            KeyRegistrationTxn: (index) => this.txn.activeGroup.getKeyRegistrationTransaction(index),
+            AssetConfigTxn: (index) => this.txn.activeGroup.getAssetConfigTransaction(index),
+            AssetTransferTxn: (index) => this.txn.activeGroup.getAssetTransferTransaction(index),
+            AssetFreezeTxn: (index) => this.txn.activeGroup.getAssetFreezeTransaction(index),
+            ApplicationTxn: (index) => this.txn.activeGroup.getApplicationTransaction(index),
+        };
+    }
+    get itxn() {
+        return {
+            submitGroup: submitGroup,
+            payment: payment,
+            keyRegistration: keyRegistration,
+            assetConfig: assetConfig,
+            assetTransfer: assetTransfer,
+            assetFreeze: assetFreeze,
+            applicationCall: applicationCall,
+        };
+    }
+    reset() {
+        this.#applicationLogs.clear();
+        this.#contractContext = new ContractContext();
+        this.#ledgerContext = new LedgerContext();
+        this.#txnContext = new TransactionContext();
+        internal.ctxMgr.reset();
+        internal.ctxMgr.instance = this;
+    }
+}
+
+export { TestExecutionContext };
+//# sourceMappingURL=index.mjs.map