@algorandfoundation/algorand-typescript-testing 1.0.0-beta.12 → 1.0.0-beta.13

package/{runtime-helpers-C6O92q80.js → encoded-types-CuGiO_X_.js}

@@ -1,14 +1,693 @@
-import { Bytes, internal, arc4, Ecdsa } from '@algorandfoundation/algorand-typescript';
+import { Bytes, internal, BaseContract, Ecdsa, arc4, Uint64 } from '@algorandfoundation/algorand-typescript';
 import { UintN, UFixedNxM, Byte, Str, Bool, StaticArray, Address, DynamicArray, Tuple, Struct, DynamicBytes, StaticBytes, ARC4Encoded } from '@algorandfoundation/algorand-typescript/arc4';
-import { a4 as asBigUintCls, F as UINT64_SIZE, b as asUint64, x as asBigUint, v as asBytesCls, L as ABI_RETURN_VALUE_LOG_PREFIX, q as asUint8Array, a5 as ALGORAND_ADDRESS_BYTE_LENGTH, a6 as ALGORAND_CHECKSUM_BYTE_LENGTH, A as Account, w as conactUint8Arrays, a7 as uint8ArrayToNumber, y as BITS_IN_BYTE, m as AccountCls, l as lazyContext, T as asBigInt, p as AssetCls, o as ApplicationCls, a8 as PROGRAM_TAG, a9 as LOGIC_DATA_PREFIX, r as asBytes, aa as log, n as nameOfType, U as Uint64BackedCls, G as MAX_UINT64 } from './log-C5qsaKI5.js';
-import js_sha512 from 'js-sha512';
 import { encodingUtil } from '@algorandfoundation/puya-ts';
 import assert from 'assert';
+import { randomBytes } from 'crypto';
 import elliptic from 'elliptic';
 import js_sha256 from 'js-sha256';
 import js_sha3 from 'js-sha3';
+import js_sha512 from 'js-sha512';
 import nacl from 'tweetnacl';
 
+const UINT64_SIZE = 64;
+const UINT512_SIZE = 512;
+const MAX_UINT8 = 2 ** 8 - 1;
+const MAX_UINT16 = 2 ** 16 - 1;
+const MAX_UINT32 = 2 ** 32 - 1;
+const MAX_UINT64 = 2n ** 64n - 1n;
+const MAX_UINT128 = 2n ** 128n - 1n;
+const MAX_UINT256 = 2n ** 256n - 1n;
+const MAX_UINT512 = 2n ** 512n - 1n;
+const MAX_BYTES_SIZE = 4096;
+const MAX_ITEMS_IN_LOG = 32;
+const MAX_BOX_SIZE = 32768;
+const BITS_IN_BYTE = 8;
+const DEFAULT_ACCOUNT_MIN_BALANCE = 100_000;
+const DEFAULT_MAX_TXN_LIFE = 1_000;
+const DEFAULT_ASSET_CREATE_MIN_BALANCE = 1000_000;
+const DEFAULT_ASSET_OPT_IN_MIN_BALANCE = 10_000;
+// from python code: list(b"\x85Y\xb5\x14x\xfd\x89\xc1vC\xd0]\x15\xa8\xaek\x10\xabG\xbbm\x8a1\x88\x11V\xe6\xbd;\xae\x95\xd1")
+const DEFAULT_GLOBAL_GENESIS_HASH = Bytes(new Uint8Array([
+    133, 89, 181, 20, 120, 253, 137, 193, 118, 67, 208, 93, 21, 168, 174, 107, 16, 171, 71, 187, 109, 138, 49, 136, 17, 86, 230, 189, 59,
+    174, 149, 209,
+]));
+// algorand encoded address of 32 zero bytes
+const ZERO_ADDRESS = Bytes.fromBase32('AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA');
+/**
+"\x09"  # pragma version 9
+"\x81\x01"  # pushint 1
+ */
+const ALWAYS_APPROVE_TEAL_PROGRAM = Bytes(new Uint8Array([0x09, 0x81, 0x01]));
+// bytes: program (logic) data prefix when signing
+const LOGIC_DATA_PREFIX = Bytes('ProgData');
+//number: minimum transaction fee
+const MIN_TXN_FEE = 1000;
+const ABI_RETURN_VALUE_LOG_PREFIX = Bytes.fromHex('151F7C75');
+const DEFAULT_TEMPLATE_VAR_PREFIX = 'TMPL_';
+const APP_ID_PREFIX = 'appID';
+const HASH_BYTES_LENGTH = 32;
+const ALGORAND_ADDRESS_BYTE_LENGTH = 36;
+const ALGORAND_CHECKSUM_BYTE_LENGTH = 4;
+const ALGORAND_ADDRESS_LENGTH = 58;
+const PROGRAM_TAG = 'Program';
+const TRANSACTION_GROUP_MAX_SIZE = 16;
+var OnApplicationComplete;
+(function (OnApplicationComplete) {
+    OnApplicationComplete[OnApplicationComplete["NoOpOC"] = 0] = "NoOpOC";
+    OnApplicationComplete[OnApplicationComplete["OptInOC"] = 1] = "OptInOC";
+    OnApplicationComplete[OnApplicationComplete["CloseOutOC"] = 2] = "CloseOutOC";
+    OnApplicationComplete[OnApplicationComplete["ClearStateOC"] = 3] = "ClearStateOC";
+    OnApplicationComplete[OnApplicationComplete["UpdateApplicationOC"] = 4] = "UpdateApplicationOC";
+    OnApplicationComplete[OnApplicationComplete["DeleteApplicationOC"] = 5] = "DeleteApplicationOC";
+})(OnApplicationComplete || (OnApplicationComplete = {}));
+
+/**
+ * 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 uint64Id = id instanceof BaseContract ? this.ledger.getApplicationForContract(id).id : internal.primitives.Uint64Cls.fromCompat(id);
+        const data = this.ledger.applicationDataMap.get(uint64Id);
+        if (!data) {
+            throw internal.errors.internalError('Unknown application, check correct testing context is active');
+        }
+        return data;
+    }
+    getVoterData(account) {
+        const data = this.ledger.voterDataMap.get(account);
+        if (!data) {
+            throw internal.errors.internalError('Unknown voter, check correct testing context is active');
+        }
+        return data;
+    }
+}
+const lazyContext = new InternalContext();
+
+const nameOfType = (x) => {
+    if (typeof x === 'object') {
+        if (x === null)
+            return 'Null';
+        if (x === undefined)
+            return 'undefined';
+        if ('constructor' in x) {
+            return x.constructor.name;
+        }
+    }
+    return typeof x;
+};
+function* iterBigInt(start, end) {
+    for (let i = start; i < end; i++) {
+        yield BigInt(i);
+    }
+}
+const asBigInt = (v) => asUint64Cls(v).asBigInt();
+const asNumber = (v) => asUint64Cls(v).asNumber();
+const asUint64Cls = (val) => internal.primitives.Uint64Cls.fromCompat(val);
+const asBigUintCls = (val) => internal.primitives.BigUintCls.fromCompat(val instanceof Uint8Array ? asBytes(val) : Array.isArray(val) ? asBytes(new Uint8Array(val)) : val);
+const asBytesCls = (val) => internal.primitives.BytesCls.fromCompat(val);
+const asUint64 = (val) => asUint64Cls(val).asAlgoTs();
+const asBigUint = (val) => asBigUintCls(val).asAlgoTs();
+const asBytes = (val) => asBytesCls(val).asAlgoTs();
+const asUint8Array = (val) => asBytesCls(val).asUint8Array();
+const asMaybeUint64Cls = (val) => {
+    try {
+        return internal.primitives.Uint64Cls.fromCompat(val);
+    }
+    catch (e) {
+        if (e instanceof internal.errors.InternalError) ;
+        else {
+            throw e;
+        }
+    }
+    return undefined;
+};
+const asMaybeBigUintCls = (val) => {
+    try {
+        return internal.primitives.BigUintCls.fromCompat(val);
+    }
+    catch (e) {
+        if (e instanceof internal.errors.InternalError) ;
+        else {
+            throw e;
+        }
+    }
+    return undefined;
+};
+const asMaybeBytesCls = (val) => {
+    try {
+        return internal.primitives.BytesCls.fromCompat(val);
+    }
+    catch (e) {
+        if (e instanceof internal.errors.InternalError) ;
+        else {
+            throw e;
+        }
+    }
+    return undefined;
+};
+const binaryStringToBytes = (s) => internal.primitives.BytesCls.fromCompat(new Uint8Array(s.match(/.{1,8}/g).map((x) => parseInt(x, 2))));
+const getRandomNumber = (min, max) => {
+    return Math.floor(Math.random() * (max - min + 1)) + min;
+};
+const getRandomBigInt = (min, max) => {
+    const bigIntMin = BigInt(min);
+    const bigIntMax = BigInt(max);
+    const randomValue = [...Array(UINT512_SIZE / BITS_IN_BYTE).keys()]
+        .map(() => getRandomNumber(0, MAX_UINT8))
+        .reduce((acc, x) => acc * 256n + BigInt(x), 0n);
+    return (randomValue % (bigIntMax - bigIntMin)) + bigIntMin;
+};
+const getRandomBytes = (length) => asBytesCls(Bytes(randomBytes(length)));
+const ObjectReferenceSymbol = Symbol('ObjectReference');
+const objectRefIter = iterBigInt(1001n, MAX_UINT512);
+const getObjectReference = (obj) => {
+    const tryGetReference = (obj) => {
+        const s = Object.getOwnPropertySymbols(obj).find((s) => s.toString() === ObjectReferenceSymbol.toString());
+        return s ? obj[s] : ObjectReferenceSymbol in obj ? obj[ObjectReferenceSymbol] : undefined;
+    };
+    const existingRef = tryGetReference(obj);
+    if (existingRef !== undefined) {
+        return existingRef;
+    }
+    const ref = objectRefIter.next().value;
+    Object.defineProperty(obj, ObjectReferenceSymbol, {
+        value: ref,
+        enumerable: false,
+        writable: false,
+    });
+    return ref;
+};
+const combineIntoMaxBytePages = (pages) => {
+    const combined = pages.reduce((acc, x) => acc.concat(x), asBytesCls(''));
+    const totalPages = (asNumber(combined.length) + MAX_BYTES_SIZE - 1) / MAX_BYTES_SIZE;
+    const result = [];
+    for (let i = 0; i < totalPages; i++) {
+        const start = i * MAX_BYTES_SIZE;
+        const end = Math.min((i + 1) * MAX_BYTES_SIZE, asNumber(combined.length));
+        const page = combined.slice(start, end);
+        result.push(page.asAlgoTs());
+    }
+    return result;
+};
+const conactUint8Arrays = (...values) => {
+    const result = new Uint8Array(values.reduce((acc, value) => acc + value.length, 0));
+    let index = 0;
+    for (const value of values) {
+        result.set(value, index);
+        index += value.length;
+    }
+    return result;
+};
+const uint8ArrayToNumber = (value) => {
+    return value.reduce((acc, x) => acc * 256 + x, 0);
+};
+
+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 = js_sha256.sha256.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 = js_sha3.sha3_256.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 = js_sha3.keccak256.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 = js_sha512.sha512_256.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 = conactUint8Arrays(asUint8Array(PROGRAM_TAG), programBytes.asUint8Array());
+    const logicSigAddress = js_sha512.sha512_256.array(logicSig);
+    const addressBytes = Bytes(logicSigAddress);
+    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 elliptic.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 elliptic.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 elliptic.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 mimc = (_c, _a) => {
+    notImplementedError('mimc');
+};
+const curveMap = {
+    [Ecdsa.Secp256k1]: 'secp256k1',
+    [Ecdsa.Secp256r1]: 'p256',
+};
+
+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 BytesBackedCls {
+    #value;
+    // #typeInfo: GenericTypeInfo | undefined
+    get bytes() {
+        return this.#value;
+    }
+    constructor(value, _typeInfo) {
+        this.#value = value;
+        // this.#typeInfo = typeInfo
+    }
+    static fromBytes(value, typeInfo) {
+        return new this(internal.primitives.BytesCls.fromCompat(value).asAlgoTs(), typeInfo);
+    }
+}
+class Uint64BackedCls {
+    #value;
+    get uint64() {
+        return this.#value;
+    }
+    constructor(value) {
+        this.#value = value;
+    }
+    static fromBytes(value) {
+        const uint8ArrayValue = value instanceof Uint8Array ? value : internal.primitives.BytesCls.fromCompat(value).asUint8Array();
+        const uint64Value = Uint64(encodingUtil.uint8ArrayToBigInt(uint8ArrayValue));
+        return new this(uint64Value);
+    }
+}
+
+class AssetHolding {
+    balance;
+    frozen;
+    constructor(balance, frozen) {
+        this.balance = asUint64(balance);
+        this.frozen = frozen;
+    }
+}
+class AccountData {
+    optedAssets = new Uint64Map();
+    optedApplications = new Uint64Map();
+    incentiveEligible = false;
+    lastProposed;
+    lastHeartbeat;
+    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(),
+        };
+    }
+}
+function Account(address) {
+    return new AccountCls(address);
+}
+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 `Asset` or `Application` instance.');
+    }
+}
+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(),
+        };
+    }
+}
+function Application(id) {
+    return new ApplicationCls(id);
+}
+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() {
+        return getApplicationAddress(this.id);
+    }
+}
+function Asset(id) {
+    return new AssetCls(id);
+}
+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;
+    }
+}
+const checksumFromPublicKey = (pk) => {
+    return Uint8Array.from(js_sha512.sha512_256.array(pk).slice(HASH_BYTES_LENGTH - ALGORAND_CHECKSUM_BYTE_LENGTH, HASH_BYTES_LENGTH));
+};
+const getApplicationAddress = (appId) => {
+    const toBeSigned = conactUint8Arrays(asUint8Array(APP_ID_PREFIX), encodingUtil.bigIntToUint8Array(asBigInt(appId), 8));
+    const appIdHash = js_sha512.sha512_256.array(toBeSigned);
+    const publicKey = Uint8Array.from(appIdHash);
+    const address = encodeAddress(publicKey);
+    return Account(Bytes.fromBase32(address));
+};
+const encodeAddress = (address) => {
+    const checksum = checksumFromPublicKey(address);
+    return encodingUtil.uint8ArrayToBase32(conactUint8Arrays(address, checksum)).slice(0, ALGORAND_ADDRESS_LENGTH);
+};
+
 const ABI_LENGTH_SIZE = 2;
 const maxBigIntValue = (bitSize) => 2n ** BigInt(bitSize) - 1n;
 const maxBytesLength = (bitSize) => Math.floor(bitSize / BITS_IN_BYTE);
@@ -331,7 +1010,7 @@ class StaticArrayImpl extends StaticArray {
     }
     static getArc4TypeName = (t) => {
         const genericArgs = t.genericArgs;
-        return `${getArc4TypeName$1(genericArgs.elementType)}[${genericArgs.size.name}]`;
+        return `${getArc4TypeName(genericArgs.elementType)}[${genericArgs.size.name}]`;
     };
 }
 class AddressImpl extends Address {
@@ -467,7 +1146,7 @@ class DynamicArrayImpl extends DynamicArray {
     }
     static getArc4TypeName = (t) => {
         const genericArgs = t.genericArgs;
-        return `${getArc4TypeName$1(genericArgs.elementType)}[]`;
+        return `${getArc4TypeName(genericArgs.elementType)}[]`;
     };
     encodeWithLength(items) {
         return conactUint8Arrays(encodeLength(items.length).asUint8Array(), encode(items));
@@ -550,7 +1229,7 @@ class TupleImpl extends Tuple {
     }
     static getArc4TypeName = (t) => {
         const genericArgs = Object.values(t.genericArgs);
-        return `(${genericArgs.map(getArc4TypeName$1).join(',')})`;
+        return `(${genericArgs.map(getArc4TypeName).join(',')})`;
     };
 }
 class StructImpl extends Struct {
@@ -618,7 +1297,7 @@ class StructImpl extends Struct {
     }
     static getArc4TypeName = (t) => {
         const genericArgs = Object.values(t.genericArgs);
-        return `(${genericArgs.map(getArc4TypeName$1).join(',')})`;
+        return `(${genericArgs.map(getArc4TypeName).join(',')})`;
     };
 }
 class DynamicBytesImpl extends DynamicBytes {
@@ -942,7 +1621,7 @@ const getArc4Encoder = (typeInfo, encoders) => {
     }
     return encoder;
 };
-const getArc4TypeName$1 = (typeInfo) => {
+const getArc4TypeName = (typeInfo) => {
     const map = {
         Address: 'address',
         Bool: 'bool',
@@ -1042,520 +1721,9 @@ const getArc4Encoded = (value) => {
     }
     throw internal.errors.codeError(`Unsupported type for encoding: ${typeof value}`);
 };
-
-const AbiMetaSymbol = Symbol('AbiMetadata');
-const isContractProxy = Symbol('isContractProxy');
-const attachAbiMetadata = (contract, methodName, metadata) => {
-    const metadatas = (AbiMetaSymbol in contract ? contract[AbiMetaSymbol] : {});
-    metadatas[methodName] = metadata;
-    if (!(AbiMetaSymbol in contract)) {
-        Object.defineProperty(contract, AbiMetaSymbol, {
-            value: metadatas,
-            writable: true,
-            enumerable: false,
-        });
-    }
-};
-const copyAbiMetadatas = (sourceContract, targetContract) => {
-    const metadatas = getContractAbiMetadata(sourceContract);
-    Object.defineProperty(targetContract, AbiMetaSymbol, {
-        value: metadatas,
-        writable: true,
-        enumerable: false,
-    });
-};
-const captureMethodConfig = (contract, methodName, config) => {
-    const metadata = getContractMethodAbiMetadata(contract, methodName);
-    metadata.onCreate = config?.onCreate ?? 'disallow';
-    metadata.allowActions = [].concat(config?.allowActions ?? 'NoOp');
-};
-const getContractAbiMetadata = (contract) => {
-    if (contract[isContractProxy]) {
-        return contract[AbiMetaSymbol];
-    }
-    const contractClass = contract.constructor;
-    const s = Object.getOwnPropertySymbols(contractClass).find((s) => s.toString() === AbiMetaSymbol.toString());
-    const metadatas = (s ? contractClass[s] : AbiMetaSymbol in contractClass ? contractClass[AbiMetaSymbol] : {});
-    return metadatas;
-};
-const getContractMethodAbiMetadata = (contract, methodName) => {
-    const metadatas = getContractAbiMetadata(contract);
-    return metadatas[methodName];
-};
-const getArc4Signature = (metadata) => {
-    if (metadata.methodSignature === undefined) {
-        const argTypes = metadata.argTypes.map((t) => JSON.parse(t)).map(getArc4TypeName);
-        const returnType = getArc4TypeName(JSON.parse(metadata.returnType));
-        metadata.methodSignature = `${metadata.methodName}(${argTypes.join(',')})${returnType}`;
-    }
-    return metadata.methodSignature;
-};
-const getArc4Selector = (metadata) => {
-    const hash = js_sha512.sha512_256.array(getArc4Signature(metadata));
-    return new Uint8Array(hash.slice(0, 4));
-};
-const getArc4TypeName = (t) => {
-    const map = {
-        void: 'void',
-        account: 'account',
-        application: 'application',
-        asset: 'asset',
-        boolean: 'bool',
-        biguint: 'uint512',
-        bytes: 'byte[]',
-        string: 'string',
-        uint64: 'uint64',
-        OnCompleteAction: 'uint64',
-        TransactionType: 'uint64',
-        Transaction: 'txn',
-        PaymentTxn: 'pay',
-        KeyRegistrationTxn: 'keyreg',
-        AssetConfigTxn: 'acfg',
-        AssetTransferTxn: 'axfer',
-        AssetFreezeTxn: 'afrz',
-        ApplicationTxn: 'appl',
-        'Tuple(<.*>)?': (t) => `(${Object.values(t.genericArgs)
-            .map(getArc4TypeName)
-            .join(',')})`,
-    };
-    const entry = Object.entries(map).find(([k, _]) => new RegExp(`^${k}$`, 'i').test(t.name))?.[1];
-    if (entry === undefined) {
-        return getArc4TypeName$1(t) ?? t.name;
-    }
-    if (entry instanceof Function) {
-        return entry(t);
-    }
-    return entry;
-};
-
-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 = js_sha256.sha256.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 = js_sha3.sha3_256.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 = js_sha3.keccak256.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 = js_sha512.sha512_256.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 = conactUint8Arrays(asUint8Array(PROGRAM_TAG), programBytes.asUint8Array());
-    const logicSigAddress = js_sha512.sha512_256.array(logicSig);
-    const addressBytes = Bytes(logicSigAddress);
-    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 elliptic.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 elliptic.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 elliptic.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 mimc = (_c, _a) => {
-    notImplementedError('mimc');
-};
-const curveMap = {
-    [Ecdsa.Secp256k1]: 'secp256k1',
-    [Ecdsa.Secp256r1]: 'p256',
+const methodSelector = (methodSignature) => {
+    return sha512_256(Bytes(encodingUtil.utf8ToUint8Array(methodSignature))).slice(0, 4);
 };
 
-function emitImpl(typeInfoString, event, ...eventProps) {
-    let eventData;
-    let eventName;
-    if (typeof event === 'string') {
-        eventData = getArc4Encoded(eventProps);
-        eventName = event;
-        const argTypes = getArc4TypeName$1(eventData.typeInfo);
-        if (eventName.indexOf('(') === -1) {
-            eventName += argTypes;
-        }
-        else if (event.indexOf(argTypes) === -1) {
-            throw internal.errors.codeError(`Event signature ${event} does not match arg types ${argTypes}`);
-        }
-    }
-    else {
-        eventData = getArc4Encoded(event);
-        const typeInfo = JSON.parse(typeInfoString);
-        const argTypes = getArc4TypeName$1(eventData.typeInfo);
-        eventName = typeInfo.name.replace(/.*</, '').replace(/>.*/, '') + argTypes;
-    }
-    const eventHash = sha512_256(eventName);
-    log(eventHash.slice(0, 4).concat(eventData.bytes));
-}
-
-function switchableValue(x) {
-    if (typeof x === 'boolean')
-        return x;
-    if (typeof x === 'bigint')
-        return x;
-    if (typeof x === 'string')
-        return x;
-    if (x instanceof internal.primitives.AlgoTsPrimitiveCls)
-        return x.valueOf();
-    internal.errors.internalError(`Cannot convert ${nameOfType(x)} to switchable value`);
-}
-function tryGetBigInt(value) {
-    if (typeof value == 'bigint')
-        return value;
-    if (typeof value == 'number' && Number.isInteger(value))
-        return BigInt(value);
-    if (value instanceof internal.primitives.Uint64Cls)
-        return value.valueOf();
-    if (value instanceof internal.primitives.BigUintCls)
-        return value.valueOf();
-    return undefined;
-}
-function binaryOp(left, right, op) {
-    if (left instanceof ARC4Encoded && right instanceof ARC4Encoded) {
-        return arc4EncodedOp(left, right, op);
-    }
-    if (left instanceof AccountCls && right instanceof AccountCls) {
-        return accountBinaryOp(left, right, op);
-    }
-    if (left instanceof Uint64BackedCls && right instanceof Uint64BackedCls) {
-        return uint64BackedClsBinaryOp(left, right, op);
-    }
-    if (left instanceof internal.primitives.BigUintCls || right instanceof internal.primitives.BigUintCls) {
-        return bigUintBinaryOp(left, right, op);
-    }
-    if (left instanceof internal.primitives.Uint64Cls || right instanceof internal.primitives.Uint64Cls) {
-        return uint64BinaryOp(left, right, op);
-    }
-    if (left instanceof internal.primitives.BytesCls || right instanceof internal.primitives.BytesCls) {
-        return bytesBinaryOp(left, right, op);
-    }
-    const lbi = tryGetBigInt(left);
-    const rbi = tryGetBigInt(right);
-    if (lbi !== undefined && rbi !== undefined) {
-        const result = defaultBinaryOp(lbi, rbi, op);
-        if (typeof result === 'boolean') {
-            return result;
-        }
-        if (typeof left === 'number' && typeof right === 'number' && result <= Number.MAX_SAFE_INTEGER) {
-            return Number(result);
-        }
-        return result;
-    }
-    return defaultBinaryOp(left, right, op);
-}
-function unaryOp(operand, op) {
-    if (operand instanceof internal.primitives.Uint64Cls) {
-        return uint64UnaryOp(operand, op);
-    }
-    return defaultUnaryOp(operand, op);
-}
-function arc4EncodedOp(left, right, op) {
-    const hasEqualsMethod = (x) => Object.hasOwn(x, 'equals') && typeof x.equals === 'function';
-    const compareEquality = (x, y) => hasEqualsMethod(x) ? x.equals(y) : y.equals(x);
-    switch (op) {
-        case '===':
-            return compareEquality(left, right);
-        case '!==':
-            return !compareEquality(left, right);
-        default:
-            internal.errors.internalError(`Unsupported operator ${op}`);
-    }
-}
-function accountBinaryOp(left, right, op) {
-    switch (op) {
-        case '===':
-        case '!==':
-            return bytesBinaryOp(left.bytes, right.bytes, op);
-        default:
-            internal.errors.internalError(`Unsupported operator ${op}`);
-    }
-}
-function uint64BackedClsBinaryOp(left, right, op) {
-    switch (op) {
-        case '===':
-        case '!==':
-            return uint64BinaryOp(left.uint64, right.uint64, op);
-        default:
-            internal.errors.internalError(`Unsupported operator ${op}`);
-    }
-}
-function uint64BinaryOp(left, right, op) {
-    const lbi = internal.primitives.Uint64Cls.fromCompat(left).valueOf();
-    const rbi = internal.primitives.Uint64Cls.fromCompat(right).valueOf();
-    const result = (function () {
-        switch (op) {
-            case '+':
-                return lbi + rbi;
-            case '-':
-                return lbi - rbi;
-            case '*':
-                return lbi * rbi;
-            case '**':
-                if (lbi === 0n && rbi === 0n) {
-                    throw internal.errors.codeError('0 ** 0 is undefined');
-                }
-                return lbi ** rbi;
-            case '/':
-                return lbi / rbi;
-            case '%':
-                return lbi % rbi;
-            case '>>':
-                if (rbi > 63n) {
-                    throw new internal.errors.CodeError('expected shift <= 63');
-                }
-                return (lbi >> rbi) & MAX_UINT64;
-            case '<<':
-                if (rbi > 63n) {
-                    throw new internal.errors.CodeError('expected shift <= 63');
-                }
-                return (lbi << rbi) & MAX_UINT64;
-            case '>':
-                return lbi > rbi;
-            case '<':
-                return lbi < rbi;
-            case '>=':
-                return lbi >= rbi;
-            case '<=':
-                return lbi <= rbi;
-            case '===':
-                return lbi === rbi;
-            case '!==':
-                return lbi !== rbi;
-            case '&':
-                return lbi & rbi;
-            case '|':
-                return lbi | rbi;
-            case '^':
-                return lbi ^ rbi;
-            default:
-                internal.errors.internalError(`Unsupported operator ${op}`);
-        }
-    })();
-    return typeof result === 'boolean' ? result : new internal.primitives.Uint64Cls(result);
-}
-function bigUintBinaryOp(left, right, op) {
-    const lbi = internal.primitives.checkBigUint(internal.primitives.BigUintCls.fromCompat(left).valueOf());
-    const rbi = internal.primitives.checkBigUint(internal.primitives.BigUintCls.fromCompat(right).valueOf());
-    const result = (function () {
-        switch (op) {
-            case '+':
-                return lbi + rbi;
-            case '-':
-                return lbi - rbi;
-            case '*':
-                return lbi * rbi;
-            case '**':
-                if (lbi === 0n && rbi === 0n) {
-                    throw internal.errors.codeError('0 ** 0 is undefined');
-                }
-                return lbi ** rbi;
-            case '/':
-                return lbi / rbi;
-            case '%':
-                return lbi % rbi;
-            case '>>':
-                throw new internal.errors.CodeError('BigUint does not support >> operator');
-            case '<<':
-                throw new internal.errors.CodeError('BigUint does not support << operator');
-            case '>':
-                return lbi > rbi;
-            case '<':
-                return lbi < rbi;
-            case '>=':
-                return lbi >= rbi;
-            case '<=':
-                return lbi <= rbi;
-            case '===':
-                return lbi === rbi;
-            case '!==':
-                return lbi !== rbi;
-            case '&':
-                return lbi & rbi;
-            case '|':
-                return lbi | rbi;
-            case '^':
-                return lbi ^ rbi;
-            default:
-                internal.errors.internalError(`Unsupported operator ${op}`);
-        }
-    })();
-    if (typeof result === 'boolean') {
-        return result;
-    }
-    if (result < 0) {
-        internal.errors.avmError('BigUint underflow');
-    }
-    return new internal.primitives.BigUintCls(result);
-}
-function bytesBinaryOp(left, right, op) {
-    const lbb = internal.primitives.checkBytes(internal.primitives.BytesCls.fromCompat(left).asUint8Array());
-    const rbb = internal.primitives.checkBytes(internal.primitives.BytesCls.fromCompat(right).asUint8Array());
-    const lbi = internal.encodingUtil.uint8ArrayToBigInt(lbb);
-    const rbi = internal.encodingUtil.uint8ArrayToBigInt(rbb);
-    const result = (function () {
-        switch (op) {
-            case '>':
-                return lbi > rbi;
-            case '<':
-                return lbi < rbi;
-            case '>=':
-                return lbi >= rbi;
-            case '<=':
-                return lbi <= rbi;
-            case '===':
-                return lbi === rbi;
-            case '!==':
-                return lbi !== rbi;
-            default:
-                internal.errors.internalError(`Unsupported operator ${op}`);
-        }
-    })();
-    return result;
-}
-function defaultBinaryOp(left, right, op) {
-    switch (op) {
-        case '+':
-            return left + right;
-        case '-':
-            return left - right;
-        case '*':
-            return left * right;
-        case '**':
-            if (left === 0n && right === 0n) {
-                throw new internal.errors.CodeError('0 ** 0 is undefined');
-            }
-            return left ** right;
-        case '/':
-            return left / right;
-        case '%':
-            return left % right;
-        case '>>':
-            if (typeof left === 'bigint' && typeof right === 'bigint') {
-                if (right > 63n) {
-                    throw new internal.errors.CodeError('expected shift <= 63');
-                }
-                return (left >> right) & MAX_UINT64;
-            }
-            return left >> right;
-        case '<<':
-            if (typeof left === 'bigint' && typeof right === 'bigint') {
-                if (right > 63n) {
-                    throw new internal.errors.CodeError('expected shift <= 63');
-                }
-                return (left << right) & MAX_UINT64;
-            }
-            return left << right;
-        case '>':
-            return left > right;
-        case '<':
-            return left < right;
-        case '>=':
-            return left >= right;
-        case '<=':
-            return left <= right;
-        case '===':
-            return left === right;
-        case '!==':
-            return left !== right;
-        case '&':
-            return left & right;
-        case '|':
-            return left | right;
-        case '^':
-            return left ^ right;
-        default:
-            internal.errors.internalError(`Unsupported operator ${op}`);
-    }
-}
-function uint64UnaryOp(operand, op) {
-    const obi = internal.primitives.Uint64Cls.fromCompat(operand).valueOf();
-    switch (op) {
-        case '~':
-            return ~obi & MAX_UINT64;
-        default:
-            internal.errors.internalError(`Unsupported operator ${op}`);
-    }
-}
-function defaultUnaryOp(_operand, op) {
-    internal.errors.internalError(`Unsupported operator ${op}`);
-}
-const genericTypeMap = new WeakMap();
-function captureGenericTypeInfo(target, t) {
-    genericTypeMap.set(target, JSON.parse(t));
-    return target;
-}
-function getGenericTypeInfo(target) {
-    return genericTypeMap.get(target);
-}
-
-export { AddressImpl as A, captureGenericTypeInfo as B, attachAbiMetadata as C, DynamicBytesImpl as D, EllipticCurve as E, emitImpl as F, decodeArc4Impl as G, UFixedNxMImpl as H, ByteImpl as I, BoolImpl as J, StaticArrayImpl as K, DynamicArrayImpl as L, StructImpl as M, StaticBytesImpl as N, interpretAsArc4Impl as O, getArc4TypeName$1 as P, getArc4Encoded as Q, StrImpl as S, TupleImpl as T, UintNImpl as U, arc4Encoders as a, ecdsaPkDecompress as b, ecdsaPkRecover as c, ecdsaVerify as d, encodeArc4Impl as e, ed25519verify as f, getArc4Encoder as g, ed25519verifyBare as h, sha3_256 as i, sha512_256 as j, keccak256 as k, getGenericTypeInfo as l, mimc as m, notImplementedError as n, getArc4Selector as o, isContractProxy as p, getContractMethodAbiMetadata as q, copyAbiMetadatas as r, sha256 as s, testInvariant as t, getContractAbiMetadata as u, vrfVerify as v, captureMethodConfig as w, switchableValue as x, binaryOp as y, unaryOp as z };
-//# sourceMappingURL=runtime-helpers-C6O92q80.js.map
+export { getArc4Encoded as $, AccountCls as A, BytesMap as B, MAX_UINT16 as C, MAX_UINT32 as D, MAX_UINT128 as E, MAX_UINT256 as F, MAX_UINT512 as G, DynamicBytesImpl as H, BITS_IN_BYTE as I, DEFAULT_TEMPLATE_VAR_PREFIX as J, asBytes as K, BytesBackedCls as L, MAX_UINT64 as M, Uint64BackedCls as N, asMaybeBigUintCls as O, combineIntoMaxBytePages as P, MAX_ITEMS_IN_LOG as Q, asUint8Array as R, StrImpl as S, TRANSACTION_GROUP_MAX_SIZE as T, Uint64Map as U, asBytesCls as V, MAX_BOX_SIZE as W, conactUint8Arrays as X, getArc4TypeName as Y, ZERO_ADDRESS as Z, nameOfType as _, ApplicationCls as a, sha512_256 as a0, decodeArc4Impl as a1, encodeArc4Impl as a2, UFixedNxMImpl as a3, ByteImpl as a4, BoolImpl as a5, StaticArrayImpl as a6, DynamicArrayImpl as a7, TupleImpl as a8, StructImpl as a9, UINT64_SIZE as aA, notImplementedError as aB, StaticBytesImpl as aa, interpretAsArc4Impl as ab, arc4Encoders as ac, getArc4Encoder as ad, methodSelector as ae, EllipticCurve as af, ecdsaPkDecompress as ag, ecdsaPkRecover as ah, ecdsaVerify as ai, ed25519verify as aj, ed25519verifyBare as ak, keccak256 as al, mimc as am, sha256 as an, sha3_256 as ao, vrfVerify as ap, getObjectReference as aq, getApplicationAddress as ar, MIN_TXN_FEE as as, DEFAULT_ACCOUNT_MIN_BALANCE as at, DEFAULT_MAX_TXN_LIFE as au, DEFAULT_ASSET_CREATE_MIN_BALANCE as av, DEFAULT_ASSET_OPT_IN_MIN_BALANCE as aw, DEFAULT_GLOBAL_GENESIS_HASH as ax, asBigUint as ay, binaryStringToBytes as az, AssetCls as b, AccountMap as c, Account as d, Asset as e, asUint64 as f, Application as g, asMaybeUint64Cls as h, iterBigInt as i, asUint64Cls as j, AssetHolding as k, lazyContext as l, AccountData as m, asBigInt as n, asMaybeBytesCls as o, asNumber as p, ABI_RETURN_VALUE_LOG_PREFIX as q, getRandomBigInt as r, MAX_BYTES_SIZE as s, testInvariant as t, getRandomBytes as u, ApplicationData as v, AddressImpl as w, UintNImpl as x, getRandomNumber as y, MAX_UINT8 as z };
+//# sourceMappingURL=encoded-types-CuGiO_X_.js.map