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

package/index.mjs

@@ -0,0 +1,4563 @@
+import { internal, Bytes, Uint64, Account, arc4, Ecdsa, op, Base64, TransactionType, Asset, Application, BigUint, BaseContract, Contract } from '@algorandfoundation/algorand-typescript';
+import algosdk from 'algosdk';
+import { a as asMaybeUint64Cls, b as asUint64, c as asBytes, d as asNumber, M as MAX_BOX_SIZE, t as toBytes, e as asBytesCls, f as asUint8Array, g as conactUint8Arrays, L as LOGIC_DATA_PREFIX, h as asBigInt, i as getObjectReference, j as MIN_TXN_FEE, D as DEFAULT_ACCOUNT_MIN_BALANCE, k as DEFAULT_MAX_TXN_LIFE, Z as ZERO_ADDRESS, l as DEFAULT_ASSET_CREATE_MIN_BALANCE, m as DEFAULT_ASSET_OPT_IN_MIN_BALANCE, n as DEFAULT_GLOBAL_GENESIS_HASH, o as asUint64Cls, p as asMaybeBytesCls, q as asBigUint, B as BITS_IN_BYTE, r as MAX_BYTES_SIZE, s as MAX_UINT8, u as binaryStringToBytes, U as UINT64_SIZE, v as MAX_UINT64, w as Uint64BackedCls, A as ALWAYS_APPROVE_TEAL_PROGRAM, x as BytesBackedCls, y as combineIntoMaxBytePages, z as MAX_ITEMS_IN_LOG, C as ABI_RETURN_VALUE_LOG_PREFIX, E as getRandomBytes, F as getArc4Encoder, G as arc4Encoders, H as getGenericTypeInfo, I as getAbiMetadata, J as iterBigInt, K as getRandomBigInt, N as captureMethodConfig } from './runtime-helpers-DlIX78iw.js';
+import { 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';
+import '@algorandfoundation/algorand-typescript/arc4';
+import '@algorandfoundation/puya-ts';
+import 'assert';
+
+/**
+ * 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(account) {
+        const data = this.ledger.accountDataMap.get(account);
+        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 data = this.ledger.applicationDataMap.get(id);
+        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(a) {
+        const acct = getAccount(a);
+        return [acct.balance, acct.balance !== 0];
+    },
+    acctMinBalance(a) {
+        const acct = getAccount(a);
+        return [acct.minBalance, acct.balance !== 0];
+    },
+    acctAuthAddr(a) {
+        const acct = getAccount(a);
+        return [acct.authAddress, acct.balance !== 0];
+    },
+    acctTotalNumUint(a) {
+        const acct = getAccount(a);
+        return [acct.totalNumUint, acct.balance !== 0];
+    },
+    acctTotalNumByteSlice(a) {
+        const acct = getAccount(a);
+        return [acct.totalNumByteSlice, acct.balance !== 0];
+    },
+    acctTotalExtraAppPages(a) {
+        const acct = getAccount(a);
+        return [acct.totalExtraAppPages, acct.balance !== 0];
+    },
+    acctTotalAppsCreated(a) {
+        const acct = getAccount(a);
+        return [acct.totalAppsCreated, acct.balance !== 0];
+    },
+    acctTotalAppsOptedIn(a) {
+        const acct = getAccount(a);
+        return [acct.totalAppsOptedIn, acct.balance !== 0];
+    },
+    acctTotalAssetsCreated(a) {
+        const acct = getAccount(a);
+        return [acct.totalAssetsCreated, acct.balance !== 0];
+    },
+    acctTotalAssets(a) {
+        const acct = getAccount(a);
+        return [acct.totalAssets, acct.balance !== 0];
+    },
+    acctTotalBoxes(a) {
+        const acct = getAccount(a);
+        return [acct.totalBoxes, acct.balance !== 0];
+    },
+    acctTotalBoxBytes(a) {
+        const acct = getAccount(a);
+        return [acct.totalBoxBytes, acct.balance !== 0];
+    },
+    // TODO: implement v11 methods
+    acctIncentiveEligible: function (_a) {
+        throw new Error('Function not implemented.');
+    },
+    acctLastProposed: function (_a) {
+        throw new Error('Function not implemented.');
+    },
+    acctLastHeartbeat: function (_a) {
+        throw new Error('Function not implemented.');
+    },
+};
+
+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(a) {
+        const app = getApp(a);
+        return app === undefined ? [Bytes(), false] : [app.approvalProgram, true];
+    },
+    appClearStateProgram(a) {
+        const app = getApp(a);
+        return app === undefined ? [Bytes(), false] : [app.clearStateProgram, true];
+    },
+    appGlobalNumUint(a) {
+        const app = getApp(a);
+        return app === undefined ? [Uint64(0), false] : [app.globalNumUint, true];
+    },
+    appGlobalNumByteSlice(a) {
+        const app = getApp(a);
+        return app === undefined ? [Uint64(0), false] : [app.globalNumBytes, true];
+    },
+    appLocalNumUint(a) {
+        const app = getApp(a);
+        return app === undefined ? [Uint64(0), false] : [app.localNumUint, true];
+    },
+    appLocalNumByteSlice(a) {
+        const app = getApp(a);
+        return app === undefined ? [Uint64(0), false] : [app.localNumBytes, true];
+    },
+    appExtraProgramPages(a) {
+        const app = getApp(a);
+        return app === undefined ? [Uint64(0), false] : [app.extraProgramPages, true];
+    },
+    appCreator(a) {
+        const app = getApp(a);
+        return app === undefined ? [Account(), false] : [app.creator, true];
+    },
+    appAddress(a) {
+        const app = getApp(a);
+        return app === undefined ? [Account(), false] : [app.address, true];
+    },
+};
+
+const AppGlobal = {
+    delete(a) {
+        lazyContext.ledger.setGlobalState(lazyContext.activeApplication, a, undefined);
+    },
+    getBytes(a) {
+        return this.getExBytes(0, asBytes(a))[0];
+    },
+    getUint64(a) {
+        return this.getExUint64(0, asBytes(a))[0];
+    },
+    getExBytes(a, b) {
+        const app = getApp(a);
+        if (app === undefined) {
+            return [Bytes(), false];
+        }
+        const [state, exists] = lazyContext.ledger.getGlobalState(app, b);
+        if (!exists) {
+            return [Bytes(), false];
+        }
+        return [state.value, exists];
+    },
+    getExUint64(a, b) {
+        const app = getApp(a);
+        if (app === undefined) {
+            return [Uint64(0), false];
+        }
+        const [state, exists] = lazyContext.ledger.getGlobalState(app, b);
+        if (!exists) {
+            return [Uint64(0), false];
+        }
+        return [state.value, exists];
+    },
+    put(a, b) {
+        lazyContext.ledger.setGlobalState(lazyContext.activeApplication, a, b);
+    },
+};
+
+const AppLocal = {
+    delete: function (a, b) {
+        const app = lazyContext.activeApplication;
+        const account = getAccount(a);
+        lazyContext.ledger.setLocalState(app, account, b, undefined);
+    },
+    getBytes: function (a, b) {
+        const account = getAccount(a);
+        return this.getExBytes(account, 0, asBytes(b))[0];
+    },
+    getUint64: function (a, b) {
+        const account = getAccount(a);
+        return this.getExUint64(account, 0, asBytes(b))[0];
+    },
+    getExBytes: function (a, b, c) {
+        const app = getApp(b);
+        const account = getAccount(a);
+        if (app === undefined || account === undefined) {
+            return [Bytes(), false];
+        }
+        const [state, exists] = lazyContext.ledger.getLocalState(app, account, c);
+        if (!exists) {
+            return [Bytes(), false];
+        }
+        return [state.value, exists];
+    },
+    getExUint64: function (a, b, c) {
+        const app = getApp(b);
+        const account = getAccount(a);
+        if (app === undefined || account === undefined) {
+            return [Uint64(0), false];
+        }
+        const [state, exists] = lazyContext.ledger.getLocalState(app, account, c);
+        if (!exists) {
+            return [Uint64(0), false];
+        }
+        return [state.value, exists];
+    },
+    put: function (a, b, c) {
+        const app = lazyContext.activeApplication;
+        const account = getAccount(a);
+        lazyContext.ledger.setLocalState(app, account, b, c);
+    },
+};
+
+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(a) {
+        const asset = getAsset(a);
+        return asset === undefined ? [Uint64(0), false] : [asset.total, true];
+    },
+    assetDecimals(a) {
+        const asset = getAsset(a);
+        return asset === undefined ? [Uint64(0), false] : [asset.decimals, true];
+    },
+    assetDefaultFrozen(a) {
+        const asset = getAsset(a);
+        return asset === undefined ? [false, false] : [asset.defaultFrozen, true];
+    },
+    assetUnitName(a) {
+        const asset = getAsset(a);
+        return asset === undefined ? [Bytes(), false] : [asset.unitName, true];
+    },
+    assetName(a) {
+        const asset = getAsset(a);
+        return asset === undefined ? [Bytes(), false] : [asset.name, true];
+    },
+    assetUrl(a) {
+        const asset = getAsset(a);
+        return asset === undefined ? [Bytes(), false] : [asset.url, true];
+    },
+    assetMetadataHash(a) {
+        const asset = getAsset(a);
+        return asset === undefined ? [Bytes(), false] : [asset.metadataHash, true];
+    },
+    assetManager(a) {
+        const asset = getAsset(a);
+        return asset === undefined ? [Account(), false] : [asset.manager, true];
+    },
+    assetReserve(a) {
+        const asset = getAsset(a);
+        return asset === undefined ? [Account(), false] : [asset.reserve, true];
+    },
+    assetFreeze(a) {
+        const asset = getAsset(a);
+        return asset === undefined ? [Account(), false] : [asset.freeze, true];
+    },
+    assetClawback(a) {
+        const asset = getAsset(a);
+        return asset === undefined ? [Account(), false] : [asset.clawback, true];
+    },
+    assetCreator(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);
+    const holding = accountData.optedAssets.get(asset.id);
+    if (holding === undefined) {
+        return undefined;
+    }
+    return holding;
+};
+const AssetHolding$1 = {
+    assetBalance(a, b) {
+        const holding = getAssetHolding(a, b);
+        return holding === undefined ? [Uint64(0), false] : [holding.balance, true];
+    },
+    assetFrozen(a, b) {
+        const holding = getAssetHolding(a, b);
+        return holding === undefined ? [false, false] : [holding.frozen, true];
+    },
+};
+
+const Box$1 = {
+    create(a, b) {
+        const name = asBytes(a);
+        const size = asNumber(b);
+        if (name.length === 0 || size > MAX_BOX_SIZE) {
+            throw new internal.errors.InternalError('Invalid box name or size');
+        }
+        const app = lazyContext.activeApplication;
+        if (lazyContext.ledger.boxExists(app, name)) {
+            return false;
+        }
+        lazyContext.ledger.setBox(app, name, new Uint8Array(size));
+        return true;
+    },
+    delete(a) {
+        const name = asBytes(a);
+        const app = lazyContext.activeApplication;
+        if (!lazyContext.ledger.boxExists(app, name)) {
+            return false;
+        }
+        lazyContext.ledger.deleteBox(app, name);
+        return true;
+    },
+    extract(a, b, c) {
+        const name = asBytes(a);
+        const start = asNumber(b);
+        const length = asNumber(c);
+        const app = lazyContext.activeApplication;
+        if (!lazyContext.ledger.boxExists(app, name)) {
+            throw new internal.errors.InternalError('Box does not exist');
+        }
+        const boxContent = lazyContext.ledger.getBox(app, name);
+        return toBytes(boxContent.slice(start, start + length));
+    },
+    get(a) {
+        const name = asBytes(a);
+        const app = lazyContext.activeApplication;
+        const boxContent = lazyContext.ledger.getBox(app, name);
+        return [toBytes(boxContent), lazyContext.ledger.boxExists(app, name)];
+    },
+    length(a) {
+        const name = asBytes(a);
+        const app = lazyContext.activeApplication;
+        const boxContent = lazyContext.ledger.getBox(app, name);
+        const exists = lazyContext.ledger.boxExists(app, name);
+        return [boxContent.length, exists];
+    },
+    put(a, b) {
+        const name = asBytes(a);
+        const app = lazyContext.activeApplication;
+        const newContent = asBytesCls(b);
+        if (lazyContext.ledger.boxExists(app, name)) {
+            const boxContent = lazyContext.ledger.getBox(app, name);
+            const length = boxContent.length;
+            if (asNumber(length) !== asNumber(newContent.length)) {
+                throw new internal.errors.InternalError('New content length does not match existing box length');
+            }
+        }
+        lazyContext.ledger.setBox(app, name, newContent.asUint8Array());
+    },
+    replace(a, b, c) {
+        const name = asBytes(a);
+        const start = asNumber(b);
+        const newContent = asUint8Array(c);
+        const app = lazyContext.activeApplication;
+        if (!lazyContext.ledger.boxExists(app, name)) {
+            throw new internal.errors.InternalError('Box does not exist');
+        }
+        const boxContent = lazyContext.ledger.getBox(app, name);
+        if (start + newContent.length > boxContent.length) {
+            throw new internal.errors.InternalError('Replacement content exceeds box size');
+        }
+        const updatedContent = conactUint8Arrays(boxContent.slice(0, start), newContent, boxContent.slice(start + newContent.length));
+        lazyContext.ledger.setBox(app, name, updatedContent);
+    },
+    resize(a, b) {
+        const name = asBytes(a);
+        const newSize = asNumber(b);
+        const app = lazyContext.activeApplication;
+        if (!lazyContext.ledger.boxExists(app, name)) {
+            throw new internal.errors.InternalError('Box does not exist');
+        }
+        const boxContent = lazyContext.ledger.getBox(app, name);
+        const size = boxContent.length;
+        let updatedContent;
+        if (newSize > size) {
+            updatedContent = conactUint8Arrays(boxContent, new Uint8Array(newSize - size));
+        }
+        else {
+            updatedContent = boxContent.slice(0, newSize);
+        }
+        lazyContext.ledger.setBox(app, name, updatedContent);
+    },
+    splice(a, b, c, d) {
+        const name = asBytes(a);
+        const start = asNumber(b);
+        const length = asNumber(c);
+        const newContent = asUint8Array(d);
+        const app = lazyContext.activeApplication;
+        if (!lazyContext.ledger.boxExists(app, name)) {
+            throw new internal.errors.InternalError('Box does not exist');
+        }
+        const boxContent = lazyContext.ledger.getBox(app, name);
+        const size = boxContent.length;
+        if (start > size) {
+            throw new internal.errors.InternalError('Start index exceeds box size');
+        }
+        const end = Math.min(start + length, size);
+        let updatedContent = conactUint8Arrays(boxContent.slice(0, start), newContent, boxContent.slice(end));
+        //  Adjust the size if necessary
+        if (updatedContent.length > size) {
+            updatedContent = updatedContent.slice(0, size);
+        }
+        else if (updatedContent.length < size) {
+            updatedContent = conactUint8Arrays(updatedContent, new Uint8Array(size - asNumber(updatedContent.length)));
+        }
+        lazyContext.ledger.setBox(app, name, updatedContent);
+    },
+};
+
+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 = Bytes(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 !== 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(x), Bytes(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 = {
+    [Ecdsa.Secp256k1]: 'secp256k1',
+    [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.fromBase32(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.fromBase32(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;
+    },
+    payoutsEnabled: false,
+    // TODO: implement v11 fields
+    payoutsGoOnlineFee: 0,
+    payoutsPercent: 0,
+    payoutsMinBalance: 0,
+    payoutsMaxBalance: 0,
+};
+
+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 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 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 === 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 Bytes(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(Number(size)));
+};
+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(internal.primitives.isUint64(a) ? asUint64Cls(a).toBytes().asAlgoTs() : asBytes(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 indexParam = internal.primitives.Uint64Cls.fromCompat(b).asNumber();
+    const bit = internal.primitives.Uint64Cls.fromCompat(c).asNumber();
+    if (uint64Cls) {
+        const binaryString = toBinaryString(uint64Cls?.toBytes().asAlgoTs());
+        const index = binaryString.length - indexParam - 1;
+        const newBytes = doSetBit(binaryString, index, bit);
+        return newBytes.toUint64().asAlgoTs();
+    }
+    else {
+        const bytesCls = asMaybeBytesCls(a);
+        testInvariant(bytesCls, 'a must be uint64 or bytes');
+        const binaryString = toBinaryString(bytesCls.asAlgoTs());
+        const newBytes = doSetBit(binaryString, indexParam, bit);
+        return newBytes.asAlgoTs();
+    }
+});
+const setByte = (a, b, c) => {
+    const binaryString = toBinaryString(internal.primitives.BytesCls.fromCompat(a).asAlgoTs());
+    const byteIndex = internal.primitives.Uint64Cls.fromCompat(b).asNumber();
+    const bitIndex = byteIndex * BITS_IN_BYTE;
+    const replacementNumber = internal.primitives.Uint64Cls.fromCompat(c);
+    const replacement = toBinaryString(replacementNumber.toBytes().at(-1).asAlgoTs());
+    if (bitIndex >= binaryString.length) {
+        internal.errors.codeError(`setByte index ${byteIndex} is beyond length`);
+    }
+    if (replacementNumber.valueOf() > MAX_UINT8) {
+        internal.errors.codeError(`setByte value ${replacementNumber.asNumber()} > ${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) => {
+    return [...internal.primitives.BytesCls.fromCompat(a).asUint8Array()].map((x) => x.toString(2).padStart(BITS_IN_BYTE, '0')).join('');
+};
+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);
+};
+
+const gloadUint64 = (a, b) => {
+    const txn = lazyContext.activeGroup.getTransaction(a);
+    const result = txn.getScratchSlot(b);
+    if (result instanceof internal.primitives.Uint64Cls) {
+        return result.asAlgoTs();
+    }
+    throw new internal.errors.InternalError('invalid scratch slot type');
+};
+const gloadBytes = (a, b) => {
+    const txn = lazyContext.activeGroup.getTransaction(a);
+    const result = txn.getScratchSlot(b);
+    if (result instanceof internal.primitives.BytesCls) {
+        return result.asAlgoTs();
+    }
+    throw new internal.errors.InternalError('invalid scratch slot type');
+};
+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);
+    },
+};
+
+const Block = {
+    blkSeed: function (a) {
+        return itob(lazyContext.ledger.getBlockContent(a).seed);
+    },
+    blkTimestamp: function (a) {
+        return asUint64(lazyContext.ledger.getBlockContent(a).timestamp);
+    },
+    // TODO: implement v11 methods
+    blkProposer: function (_a) {
+        throw new Error('Function not implemented.');
+    },
+    blkFeesCollected: function (_a) {
+        throw new Error('Function not implemented.');
+    },
+    blkBonus: function (_a) {
+        throw new Error('Function not implemented.');
+    },
+    blkBranch: function (_a) {
+        throw new Error('Function not implemented.');
+    },
+    blkFeeSink: function (_a) {
+        throw new Error('Function not implemented.');
+    },
+    blkProtocol: function (_a) {
+        throw new Error('Function not implemented.');
+    },
+    blkTxnCounter: function (_a) {
+        throw new Error('Function not implemented.');
+    },
+    blkProposerPayout: function (_a) {
+        throw new Error('Function not implemented.');
+    },
+};
+
+const gaid = (a) => {
+    const group = lazyContext.activeGroup;
+    const transaction = group.getTransaction(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;
+    },
+};
+
+var ops = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AcctParams: AcctParams,
+    AppGlobal: AppGlobal,
+    AppLocal: AppLocal,
+    AppParams: AppParams,
+    AssetHolding: AssetHolding$1,
+    AssetParams: AssetParams,
+    Block: Block,
+    Box: Box$1,
+    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,
+    gloadBytes: gloadBytes,
+    gloadUint64: gloadUint64,
+    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 CustomKeyMap {
+    #keySerializer;
+    #map = new Map();
+    constructor(keySerializer) {
+        this.#keySerializer = keySerializer;
+    }
+    clear() {
+        this.#map.clear();
+    }
+    delete(key) {
+        return this.#map.delete(this.#keySerializer(key));
+    }
+    forEach(callbackfn, thisArg) {
+        for (const [key, value] of this.#map.values()) {
+            callbackfn.call(thisArg ?? this, value, key, this);
+        }
+    }
+    get(key) {
+        return this.#map.get(this.#keySerializer(key))?.[1];
+    }
+    getOrFail(key) {
+        const value = this.get(key);
+        if (value === undefined) {
+            throw internal.errors.internalError('Key not found');
+        }
+        return value;
+    }
+    has(key) {
+        return this.#map.has(this.#keySerializer(key));
+    }
+    set(key, value) {
+        this.#map.set(this.#keySerializer(key), [key, value]);
+        return this;
+    }
+    get size() {
+        return this.#map.size;
+    }
+    entries() {
+        return this.#map.values();
+    }
+    *keys() {
+        for (const [key] of this.#map.values()) {
+            yield key;
+        }
+    }
+    *values() {
+        for (const [, value] of this.#map.values()) {
+            yield value;
+        }
+    }
+    [Symbol.iterator]() {
+        return this.#map.values();
+    }
+    get [Symbol.toStringTag]() {
+        return this.constructor.name;
+    }
+}
+class AccountMap extends CustomKeyMap {
+    constructor() {
+        super(AccountMap.getAddressStrFromAccount);
+    }
+    static getAddressStrFromAccount = (acc) => {
+        return asBytesCls(acc.bytes).valueOf();
+    };
+}
+class BytesMap extends CustomKeyMap {
+    constructor() {
+        super((bytes) => asBytesCls(bytes).valueOf());
+    }
+}
+class Uint64Map extends CustomKeyMap {
+    constructor() {
+        super((uint64) => asUint64Cls(uint64).valueOf());
+    }
+}
+
+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: [],
+            globalStates: new BytesMap(),
+            localStates: new BytesMap(),
+            boxes: new BytesMap(),
+        };
+    }
+}
+class ApplicationCls extends Uint64BackedCls {
+    get id() {
+        return this.uint64;
+    }
+    constructor(id) {
+        super(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.fromBase32(addr));
+    }
+}
+
+class AssetCls extends Uint64BackedCls {
+    get id() {
+        return this.uint64;
+    }
+    constructor(id) {
+        super(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);
+        const assetHolding = accountData.optedAssets.get(this.id);
+        if (assetHolding === undefined) {
+            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 assetHolding;
+    }
+}
+
+class AssetHolding {
+    balance;
+    frozen;
+    constructor(balance, frozen) {
+        this.balance = asUint64(balance);
+        this.frozen = frozen;
+    }
+}
+class AccountData {
+    optedAssets = new Uint64Map();
+    optedApplications = new Uint64Map();
+    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 extends BytesBackedCls {
+    constructor(address) {
+        const addressBytes = address ?? ZERO_ADDRESS;
+        if (![32n, 36n].includes(asUint64Cls(addressBytes.length).valueOf())) {
+            throw new internal.errors.AvmError('Address must be 32 bytes long, or 36 bytes including checksum');
+        }
+        super(addressBytes.slice(0, 32));
+    }
+    get data() {
+        return lazyContext.getAccountData(this);
+    }
+    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(assetOrApp.id);
+        }
+        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] : []);
+        Object.entries(fields.scratchSpace ?? {}).forEach(([k, v]) => this.setScratchSlot(Number(k), 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));
+    }
+    /* @internal */
+    logArc4ReturnValue(value) {
+        this.appendLog(ABI_RETURN_VALUE_LOG_PREFIX.concat(toBytes(value)));
+    }
+}
+
+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();
+    }
+};
+
+const booleanFromBytes = (val) => {
+    return internal.encodingUtil.uint8ArrayToBigInt(asUint8Array(val)) > 0n;
+};
+const bigUintFromBytes = (val) => {
+    return BigUint(internal.encodingUtil.uint8ArrayToBigInt(asUint8Array(val)));
+};
+const bytesFromBytes = (val) => {
+    return asBytes(val);
+};
+const stringFromBytes = (val) => {
+    return asBytes(val).toString();
+};
+const uint64FromBytes = (val) => {
+    return Uint64(internal.encodingUtil.uint8ArrayToBigInt(asUint8Array(val)));
+};
+const onCompletionFromBytes = (val) => {
+    return Uint64(internal.encodingUtil.uint8ArrayToBigInt(asUint8Array(val)));
+};
+const transactionTypeFromBytes = (val) => {
+    return Uint64(internal.encodingUtil.uint8ArrayToBigInt(asUint8Array(val)));
+};
+const encoders = {
+    account: AccountCls.fromBytes,
+    application: ApplicationCls.fromBytes,
+    asset: AssetCls.fromBytes,
+    boolean: booleanFromBytes,
+    biguint: bigUintFromBytes,
+    bytes: bytesFromBytes,
+    string: stringFromBytes,
+    uint64: uint64FromBytes,
+    OnCompleteAction: onCompletionFromBytes,
+    TransactionType: transactionTypeFromBytes,
+    ...arc4Encoders,
+};
+const getEncoder = (typeInfo) => {
+    return getArc4Encoder(typeInfo, encoders);
+};
+
+class GlobalStateCls {
+    _type = GlobalStateCls.name;
+    #value;
+    key;
+    get hasKey() {
+        return this.key !== undefined && this.key.length > 0;
+    }
+    delete = () => {
+        if (this.#value instanceof internal.primitives.Uint64Cls) {
+            this.#value = Uint64(0);
+        }
+        else {
+            this.#value = undefined;
+        }
+    };
+    static [Symbol.hasInstance](x) {
+        return x instanceof Object && '_type' in x && x['_type'] === GlobalStateCls.name;
+    }
+    get value() {
+        if (this.#value === undefined) {
+            throw new internal.errors.AssertError('value is not set');
+        }
+        return this.#value;
+    }
+    set value(v) {
+        this.#value = v;
+    }
+    get hasValue() {
+        return this.#value !== undefined;
+    }
+    constructor(key, value) {
+        this.key = key !== undefined ? asBytes(key) : undefined;
+        this.#value = value;
+    }
+}
+class LocalStateCls {
+    #value;
+    delete = () => {
+        if (this.#value instanceof internal.primitives.Uint64Cls) {
+            this.#value = Uint64(0);
+        }
+        else {
+            this.#value = undefined;
+        }
+    };
+    get value() {
+        if (this.#value === undefined) {
+            throw new internal.errors.AssertError('value is not set');
+        }
+        return this.#value;
+    }
+    set value(v) {
+        this.#value = v;
+    }
+    get hasValue() {
+        return this.#value !== undefined;
+    }
+}
+class LocalStateMapCls {
+    #value = new AccountMap();
+    getValue(account) {
+        if (!this.#value.has(account)) {
+            this.#value.set(account, new LocalStateCls());
+        }
+        return this.#value.getOrFail(account);
+    }
+}
+function GlobalState(options) {
+    return new GlobalStateCls(options?.key, options?.initialValue);
+}
+function LocalState(options) {
+    function localStateInternal(account) {
+        return localStateInternal.map.getValue(account);
+    }
+    localStateInternal.key = options?.key;
+    localStateInternal.hasKey = options?.key !== undefined && options.key.length > 0;
+    localStateInternal.map = new LocalStateMapCls();
+    return localStateInternal;
+}
+class BoxCls {
+    #key;
+    #app;
+    _type = BoxCls.name;
+    static [Symbol.hasInstance](x) {
+        return x instanceof Object && '_type' in x && x['_type'] === BoxCls.name;
+    }
+    constructor(key) {
+        this.#key = key ? asBytes(key) : undefined;
+        this.#app = lazyContext.activeApplication;
+    }
+    get fromBytes() {
+        const typeInfo = getGenericTypeInfo(this);
+        const valueType = typeInfo.genericArgs[0];
+        return (val) => getEncoder(valueType)(val, valueType);
+    }
+    get value() {
+        if (!this.exists) {
+            throw new internal.errors.InternalError('Box has not been created');
+        }
+        return this.fromBytes(lazyContext.ledger.getBox(this.#app, this.key));
+    }
+    set value(v) {
+        lazyContext.ledger.setBox(this.#app, this.key, asUint8Array(toBytes(v)));
+    }
+    get hasKey() {
+        return this.#key !== undefined && this.#key.length > 0;
+    }
+    get key() {
+        if (this.#key === undefined || this.#key.length === 0) {
+            throw new internal.errors.InternalError('Box key is empty');
+        }
+        return this.#key;
+    }
+    set key(key) {
+        this.#key = asBytes(key);
+    }
+    get exists() {
+        return lazyContext.ledger.boxExists(this.#app, this.key);
+    }
+    get length() {
+        if (!this.exists) {
+            throw new internal.errors.InternalError('Box has not been created');
+        }
+        return toBytes(this.value).length;
+    }
+    get(options) {
+        const [value, exists] = this.maybe();
+        return exists ? value : options.default;
+    }
+    delete() {
+        return lazyContext.ledger.deleteBox(this.#app, this.key);
+    }
+    maybe() {
+        const value = this.fromBytes(lazyContext.ledger.getBox(this.#app, this.key));
+        return [value, lazyContext.ledger.boxExists(this.#app, this.key)];
+    }
+}
+class BoxMapCls {
+    #keyPrefix;
+    #app;
+    _type = BoxMapCls.name;
+    static [Symbol.hasInstance](x) {
+        return x instanceof Object && '_type' in x && x['_type'] === BoxMapCls.name;
+    }
+    get fromBytes() {
+        const typeInfo = getGenericTypeInfo(this);
+        const valueType = typeInfo.genericArgs[1];
+        return (val) => getEncoder(valueType)(val, valueType);
+    }
+    constructor(keyPrefix) {
+        this.#keyPrefix = keyPrefix ? asBytes(keyPrefix) : undefined;
+        this.#app = lazyContext.activeApplication;
+    }
+    get hasKeyPrefix() {
+        return this.#keyPrefix !== undefined && this.#keyPrefix.length > 0;
+    }
+    get keyPrefix() {
+        if (this.#keyPrefix === undefined || this.#keyPrefix.length === 0) {
+            throw new internal.errors.InternalError('Box key prefix is empty');
+        }
+        return this.#keyPrefix;
+    }
+    set keyPrefix(keyPrefix) {
+        this.#keyPrefix = asBytes(keyPrefix);
+    }
+    get(key, options) {
+        const [value, exists] = this.maybe(key);
+        if (!exists && options === undefined) {
+            throw new internal.errors.InternalError('Box has not been created');
+        }
+        return exists ? value : options.default;
+    }
+    set(key, value) {
+        lazyContext.ledger.setBox(this.#app, this.getFullKey(key), asUint8Array(toBytes(value)));
+    }
+    delete(key) {
+        return lazyContext.ledger.deleteBox(this.#app, this.getFullKey(key));
+    }
+    has(key) {
+        return lazyContext.ledger.boxExists(this.#app, this.getFullKey(key));
+    }
+    maybe(key) {
+        const fullKey = this.getFullKey(key);
+        const value = this.fromBytes(lazyContext.ledger.getBox(this.#app, fullKey));
+        return [value, lazyContext.ledger.boxExists(this.#app, fullKey)];
+    }
+    length(key) {
+        return toBytes(this.get(key)).length;
+    }
+    getFullKey(key) {
+        return this.keyPrefix.concat(toBytes(key));
+    }
+}
+class BoxRefCls {
+    #key;
+    #app;
+    _type = BoxRefCls.name;
+    static [Symbol.hasInstance](x) {
+        return x instanceof Object && '_type' in x && x['_type'] === BoxRefCls.name;
+    }
+    constructor(key) {
+        this.#key = key ? asBytes(key) : undefined;
+        this.#app = lazyContext.activeApplication;
+    }
+    get hasKey() {
+        return this.#key !== undefined && this.#key.length > 0;
+    }
+    get key() {
+        if (this.#key === undefined || this.#key.length === 0) {
+            throw new internal.errors.InternalError('Box key is empty');
+        }
+        return this.#key;
+    }
+    set key(key) {
+        this.#key = asBytes(key);
+    }
+    get value() {
+        if (!this.exists) {
+            throw new internal.errors.InternalError('Box has not been created');
+        }
+        return toBytes(this.backingValue);
+    }
+    set value(v) {
+        const bytesValue = asBytesCls(v);
+        const content = this.backingValue;
+        if (this.exists && content.length !== bytesValue.length.asNumber()) {
+            throw new internal.errors.InternalError('Box already exists with a different size');
+        }
+        this.backingValue = bytesValue.asUint8Array();
+    }
+    get exists() {
+        return lazyContext.ledger.boxExists(this.#app, this.key);
+    }
+    create(options) {
+        const size = asNumber(options.size);
+        if (size > MAX_BOX_SIZE) {
+            throw new internal.errors.InternalError(`Box size cannot exceed ${MAX_BOX_SIZE}`);
+        }
+        const content = this.backingValue;
+        if (this.exists && content.length !== size) {
+            throw new internal.errors.InternalError('Box already exists with a different size');
+        }
+        if (this.exists) {
+            return false;
+        }
+        this.backingValue = new Uint8Array(size);
+        return true;
+    }
+    get(options) {
+        const [value, exists] = this.maybe();
+        return exists ? value : asBytes(options.default);
+    }
+    put(value) {
+        this.value = value;
+    }
+    splice(start, length, value) {
+        const content = this.backingValue;
+        const startNumber = asNumber(start);
+        const lengthNumber = asNumber(length);
+        const valueBytes = asBytesCls(value);
+        if (!this.exists) {
+            throw new internal.errors.InternalError('Box has not been created');
+        }
+        if (startNumber > content.length) {
+            throw new internal.errors.InternalError('Start index exceeds box size');
+        }
+        const end = Math.min(startNumber + lengthNumber, content.length);
+        let updatedContent = conactUint8Arrays(content.slice(0, startNumber), valueBytes.asUint8Array(), content.slice(end));
+        if (updatedContent.length > content.length) {
+            updatedContent = updatedContent.slice(0, content.length);
+        }
+        else if (updatedContent.length < content.length) {
+            updatedContent = conactUint8Arrays(updatedContent, new Uint8Array(content.length - updatedContent.length));
+        }
+        this.backingValue = updatedContent;
+    }
+    replace(start, value) {
+        const content = this.backingValue;
+        const startNumber = asNumber(start);
+        const valueBytes = asBytesCls(value);
+        if (!this.exists) {
+            throw new internal.errors.InternalError('Box has not been created');
+        }
+        if (startNumber + asNumber(valueBytes.length) > content.length) {
+            throw new internal.errors.InternalError('Replacement content exceeds box size');
+        }
+        const updatedContent = conactUint8Arrays(content.slice(0, startNumber), valueBytes.asUint8Array(), content.slice(startNumber + valueBytes.length.asNumber()));
+        this.backingValue = updatedContent;
+    }
+    extract(start, length) {
+        const content = this.backingValue;
+        const startNumber = asNumber(start);
+        const lengthNumber = asNumber(length);
+        if (!this.exists) {
+            throw new internal.errors.InternalError('Box has not been created');
+        }
+        if (startNumber + lengthNumber > content.length) {
+            throw new internal.errors.InternalError('Index out of bounds');
+        }
+        return toBytes(content.slice(startNumber, startNumber + lengthNumber));
+    }
+    delete() {
+        return lazyContext.ledger.deleteBox(this.#app, this.key);
+    }
+    resize(newSize) {
+        const newSizeNumber = asNumber(newSize);
+        if (newSizeNumber > MAX_BOX_SIZE) {
+            throw new internal.errors.InternalError(`Box size cannot exceed ${MAX_BOX_SIZE}`);
+        }
+        const content = this.backingValue;
+        if (!this.exists) {
+            throw new internal.errors.InternalError('Box has not been created');
+        }
+        let updatedContent;
+        if (newSizeNumber > content.length) {
+            updatedContent = conactUint8Arrays(content, new Uint8Array(newSizeNumber - content.length));
+        }
+        else {
+            updatedContent = content.slice(0, newSize);
+        }
+        this.backingValue = updatedContent;
+    }
+    maybe() {
+        return [Bytes(lazyContext.ledger.getBox(this.#app, this.key)), lazyContext.ledger.boxExists(this.#app, this.key)];
+    }
+    get length() {
+        if (!this.exists) {
+            throw new internal.errors.InternalError('Box has not been created');
+        }
+        return this.backingValue.length;
+    }
+    get backingValue() {
+        return lazyContext.ledger.getBox(this.#app, this.key);
+    }
+    set backingValue(value) {
+        lazyContext.ledger.setBox(this.#app, this.key, value);
+    }
+}
+function Box(options) {
+    return new BoxCls(options?.key);
+}
+function BoxMap(options) {
+    return new BoxMapCls(options?.keyPrefix);
+}
+function BoxRef(options) {
+    return new BoxRefCls(options?.key);
+}
+
+const isUint64GenericType = (typeInfo) => {
+    if (!Array.isArray(typeInfo?.genericArgs) || !typeInfo?.genericArgs?.length)
+        return false;
+    return typeInfo.genericArgs.some((t) => t.name.toLocaleLowerCase() === 'uint64');
+};
+const extractStates = (contract) => {
+    const stateTotals = { globalNumBytes: 0, globalNumUint: 0, localNumBytes: 0, localNumUint: 0 };
+    const states = {
+        globalStates: new BytesMap(),
+        localStates: new BytesMap(),
+        totals: stateTotals,
+    };
+    Object.entries(contract).forEach(([key, value]) => {
+        const isLocalState = value instanceof Function && value.name === 'localStateInternal';
+        const isGlobalState = value instanceof GlobalStateCls;
+        const isBox = value instanceof BoxCls;
+        const isBoxRef = value instanceof BoxRefCls;
+        const isBoxMap = value instanceof BoxMapCls;
+        if (isLocalState || isGlobalState || isBox || isBoxRef) {
+            // set key using property name if not already set
+            if (!value.hasKey)
+                value.key = Bytes(key);
+        }
+        else if (isBoxMap) {
+            if (!value.hasKeyPrefix)
+                value.keyPrefix = Bytes(key);
+        }
+        if (isLocalState || isGlobalState) {
+            // capture state into the context
+            if (isLocalState)
+                states.localStates.set(value.key, value);
+            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 = (app, args) => {
+    const transactions = [];
+    const accounts = [];
+    const apps = [app];
+    const assets = [];
+    const appArgs = [];
+    // TODO: replace `asUint64Cls(accounts.length).toBytes().asAlgoTs()` with `arc4.Uint8(account.length).toBytes().asAlgoTs()`
+    for (const arg of args) {
+        if (isTransaction(arg)) {
+            transactions.push(arg);
+        }
+        else if (arg instanceof AccountCls) {
+            appArgs.push(asUint64Cls(accounts.length).toBytes().asAlgoTs());
+            accounts.push(arg);
+        }
+        else if (arg instanceof ApplicationCls) {
+            appArgs.push(asUint64Cls(apps.length).toBytes().asAlgoTs());
+            apps.push(arg);
+        }
+        else if (arg instanceof AssetCls) {
+            appArgs.push(asUint64Cls(assets.length).toBytes().asAlgoTs());
+            assets.push(arg);
+        }
+    }
+    // TODO: use actual method selector in appArgs
+    return { accounts, apps, assets, transactions, appArgs: [Bytes('method_selector'), ...appArgs] };
+};
+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(this.isArc4(type)));
+        return new proxy(...args);
+    }
+    static createMethodCallTxns(contract, method, ...args) {
+        const abiMetadata = getAbiMetadata(contract, method.name);
+        const app = lazyContext.ledger.getApplicationForContract(contract);
+        const { transactions, ...appCallArgs } = extractArraysFromArgs(app, args);
+        const appTxn = lazyContext.any.txn.applicationCall({
+            appId: app,
+            ...appCallArgs,
+            // TODO: This needs to be specifiable by the test code
+            onCompletion: (abiMetadata?.allowActions ?? [])[0],
+        });
+        const txns = [...(transactions ?? []), appTxn];
+        return txns;
+    }
+    isArc4(type) {
+        const proto = Object.getPrototypeOf(type);
+        if (proto === BaseContract) {
+            return false;
+        }
+        else if (proto === Contract) {
+            return true;
+        }
+        else if (proto === Object) {
+            throw new Error('Cannot create a contract for class as it does not extend Contract or BaseContract');
+        }
+        return this.isArc4(proto);
+    }
+    getContractProxyHandler(isArc4) {
+        const onConstructed = (application, instance) => {
+            const states = extractStates(instance);
+            const applicationData = lazyContext.ledger.applicationDataMap.getOrFail(application.id);
+            applicationData.application = {
+                ...applicationData.application,
+                globalStates: states.globalStates,
+                localStates: states.localStates,
+                ...states.totals,
+            };
+            lazyContext.ledger.addAppIdContractMap(application.id, instance);
+        };
+        return {
+            construct(target, args) {
+                let t = undefined;
+                const application = lazyContext.any.application();
+                const txn = lazyContext.any.txn.applicationCall({ appId: application });
+                lazyContext.txn.ensureScope([txn]).execute(() => {
+                    t = new target(...args);
+                });
+                const instance = new Proxy(t, {
+                    get(target, prop, receiver) {
+                        const orig = Reflect.get(target, prop, receiver);
+                        const abiMetadata = getAbiMetadata(target, prop);
+                        const isProgramMethod = prop === 'approvalProgram' || prop === 'clearStateProgram';
+                        const isAbiMethod = isArc4 && abiMetadata;
+                        if (isAbiMethod || isProgramMethod) {
+                            return (...args) => {
+                                const txns = ContractContext.createMethodCallTxns(receiver, orig, ...args);
+                                return lazyContext.txn.ensureScope(txns).execute(() => {
+                                    const returnValue = orig.apply(target, args);
+                                    if (!isProgramMethod && isAbiMethod && returnValue !== undefined) {
+                                        txns.at(-1).logArc4ReturnValue(returnValue);
+                                    }
+                                    return returnValue;
+                                });
+                            };
+                        }
+                        return orig;
+                    },
+                });
+                onConstructed(application, instance);
+                return instance;
+            },
+        };
+    }
+}
+
+class LedgerContext {
+    appIdIter = iterBigInt(1001n, MAX_UINT64);
+    assetIdIter = iterBigInt(1001n, MAX_UINT64);
+    applicationDataMap = new Uint64Map();
+    appIdContractMap = new Uint64Map();
+    accountDataMap = new AccountMap();
+    assetDataMap = new Uint64Map();
+    blocks = new Uint64Map();
+    globalData = new GlobalData();
+    addAppIdContractMap(appId, contract) {
+        this.appIdContractMap.set(appId, contract);
+    }
+    getAsset(assetId) {
+        if (this.assetDataMap.has(assetId)) {
+            return Asset(asUint64(assetId));
+        }
+        throw internal.errors.internalError('Unknown asset, check correct testing context is active');
+    }
+    getApplication(applicationId) {
+        if (this.applicationDataMap.has(applicationId)) {
+            return Application(asUint64(applicationId));
+        }
+        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 account
+     * @param assetId
+     * @param balance
+     * @param frozen
+     */
+    updateAssetHolding(account, assetId, balance, frozen) {
+        const id = asMaybeUint64Cls(assetId) ?? asUint64Cls(assetId.id);
+        const accountData = this.accountDataMap.get(account);
+        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,
+        };
+    }
+    setBlock(index, seed, timestamp) {
+        const i = asBigInt(index);
+        const s = asBigInt(seed);
+        const t = asBigInt(timestamp);
+        this.blocks.set(i, { seed: s, timestamp: t });
+    }
+    getBlockContent(index) {
+        const i = asBigInt(index);
+        if (this.blocks.has(i)) {
+            return this.blocks.get(i);
+        }
+        throw internal.errors.internalError(`Block ${i} not set`);
+    }
+    getGlobalState(app, key) {
+        const appData = this.applicationDataMap.get(app.id);
+        if (!appData?.application.globalStates.has(key)) {
+            return [undefined, false];
+        }
+        return [appData.application.globalStates.getOrFail(key), true];
+    }
+    setGlobalState(app, key, value) {
+        const appData = this.applicationDataMap.getOrFail(app.id);
+        const globalState = appData.application.globalStates.getOrFail(key);
+        if (value === undefined) {
+            globalState.delete();
+        }
+        else {
+            globalState.value = asMaybeUint64Cls(value) ?? asMaybeBytesCls(value);
+        }
+    }
+    getLocalState(app, account, key) {
+        const appData = this.applicationDataMap.get(app.id);
+        if (!appData?.application.localStates.has(key)) {
+            return [undefined, false];
+        }
+        const localState = appData.application.localStates.getOrFail(key);
+        return [localState(account), true];
+    }
+    setLocalState(app, account, key, value) {
+        const appData = this.applicationDataMap.getOrFail(app.id);
+        const localState = appData.application.localStates.getOrFail(key);
+        const accountLocalState = localState(account);
+        if (value === undefined) {
+            accountLocalState.delete();
+        }
+        else {
+            accountLocalState.value = asMaybeUint64Cls(value) ?? asMaybeBytesCls(value);
+        }
+    }
+    getBox(app, key) {
+        const appData = this.applicationDataMap.getOrFail(app.id);
+        return appData.application.boxes.get(key) ?? new Uint8Array();
+    }
+    setBox(app, key, value) {
+        const appData = this.applicationDataMap.getOrFail(app.id);
+        appData.application.boxes.set(key, value);
+    }
+    deleteBox(app, key) {
+        const appData = this.applicationDataMap.getOrFail(app.id);
+        return appData.application.boxes.delete(key);
+    }
+    boxExists(app, key) {
+        const appData = this.applicationDataMap.getOrFail(app.id);
+        return appData.application.boxes.has(key);
+    }
+}
+
+function decodeLogs(logs, decoding) {
+    return logs.map((log, i) => {
+        switch (decoding[i]) {
+            case 'i':
+                return op.btoi(log);
+            case 's':
+                return log.toString();
+            default:
+                return log;
+        }
+    });
+}
+
+function ScopeGenerator(dispose) {
+    function* internal() {
+        try {
+            yield;
+        }
+        finally {
+            dispose();
+        }
+    }
+    const scope = internal();
+    scope.next();
+    return {
+        done: () => {
+            scope.return();
+        },
+    };
+}
+class DeferredAppCall {
+    appId;
+    txns;
+    method;
+    args;
+    constructor(appId, txns, method, args) {
+        this.appId = appId;
+        this.txns = txns;
+        this.method = method;
+        this.args = args;
+    }
+    submit() {
+        // TODO: check_routing_conditions
+        return this.method(...this.args);
+    }
+}
+class TransactionContext {
+    groups = [];
+    #activeGroup;
+    createScope(group, activeTransactionIndex) {
+        const transactions = group.map((t) => (t instanceof DeferredAppCall ? t.txns : [t])).flat();
+        const transactionGroup = new TransactionGroup(transactions, 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);
+    }
+    deferAppCall(contract, method, ...args) {
+        const appId = lazyContext.ledger.getApplicationForContract(contract);
+        const txns = ContractContext.createMethodCallTxns(contract, method, ...args);
+        return new DeferredAppCall(appId.id, txns, method, args);
+    }
+    exportLogs(appId, ...decoding) {
+        const transaction = this.lastGroup.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;
+        }
+        return decodeLogs(logs, 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);
+    }
+    getScratchSpace() {
+        return this.activeTransaction.scratchSpace;
+    }
+    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 account = input?.address ?? Account(Bytes.fromBase32(algosdk.generateAccount().addr));
+        if (input?.address && lazyContext.ledger.accountDataMap.has(account)) {
+            internal.errors.internalError('Account with such address already exists in testing context. Use `context.ledger.getAccount(address)` to retrieve the existing account.');
+        }
+        const data = new AccountData();
+        const { address, optedAssetBalances, optedApplications, ...accountData } = input ?? {};
+        data.account = {
+            ...data.account,
+            ...accountData,
+        };
+        lazyContext.ledger.accountDataMap.set(account, data);
+        if (input?.optedAssetBalances) {
+            for (const [assetId, balance] of input.optedAssetBalances) {
+                lazyContext.ledger.updateAssetHolding(account, assetId, balance);
+            }
+        }
+        if (input?.optedApplications) {
+            for (const app of input.optedApplications) {
+                data.optedApplications.set(asBigInt(app.id), app);
+            }
+        }
+        return account;
+    }
+    asset(input) {
+        const id = input?.assetId;
+        if (id && lazyContext.ledger.assetDataMap.has(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, {
+            ...defaultAssetData,
+            ...assetData,
+        });
+        return new AssetCls(assetId.asAlgoTs());
+    }
+    application(input) {
+        const id = input?.applicationId;
+        if (id && lazyContext.ledger.applicationDataMap.has(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, data);
+        return new ApplicationCls(applicationId.asAlgoTs());
+    }
+}
+
+class TxnValueGenerator {
+    applicationCall(fields) {
+        const params = fields ?? {};
+        if (params.appId && !lazyContext.ledger.applicationDataMap.has(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 {
+    #contractContext;
+    #ledgerContext;
+    #txnContext;
+    #valueGenerator;
+    #defaultSender;
+    constructor() {
+        internal.ctxMgr.instance = this;
+        this.#contractContext = new ContractContext();
+        this.#ledgerContext = new LedgerContext();
+        this.#txnContext = new TransactionContext();
+        this.#valueGenerator = new ValueGenerator();
+        this.#defaultSender = Account(Bytes.fromBase32(algosdk.generateAccount().addr));
+    }
+    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,
+        };
+    }
+    get state() {
+        return {
+            GlobalState,
+            LocalState,
+            Box,
+            BoxMap,
+            BoxRef,
+        };
+    }
+    reset() {
+        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