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

package/runtime-helpers-DlIX78iw.js

@@ -0,0 +1,1426 @@
+import { Bytes, internal, Uint64, Account } from '@algorandfoundation/algorand-typescript';
+import { UintN, UFixedNxM, Byte, Str, Bool, StaticArray, Address, DynamicArray, Tuple, Struct, DynamicBytes, StaticBytes, ARC4Encoded } from '@algorandfoundation/algorand-typescript/arc4';
+import { randomBytes } from 'crypto';
+import { encodingUtil } from '@algorandfoundation/puya-ts';
+import { decodeAddress } from 'algosdk';
+import assert from 'assert';
+
+const AbiMetaSymbol = Symbol('AbiMetadata');
+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 captureMethodConfig = (contract, methodName, config) => {
+    const metadata = ensureMetadata(contract, methodName);
+    metadata.onCreate = config?.onCreate ?? 'disallow';
+    metadata.allowActions = [].concat(config?.allowActions ?? 'NoOp');
+};
+const ensureMetadata = (contract, methodName) => {
+    if (!hasAbiMetadata(contract)) {
+        const contractClass = contract.constructor;
+        Object.getOwnPropertyNames(Object.getPrototypeOf(contract)).forEach((name) => {
+            attachAbiMetadata(contractClass, name, { methodName: name, methodSelector: name, argTypes: [], returnType: '' });
+        });
+    }
+    return getAbiMetadata(contract, methodName);
+};
+const hasAbiMetadata = (contract) => {
+    const contractClass = contract.constructor;
+    return (Object.getOwnPropertySymbols(contractClass).some((s) => s.toString() === AbiMetaSymbol.toString()) || AbiMetaSymbol in contractClass);
+};
+const getAbiMetadata = (contract, methodName) => {
+    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[methodName];
+};
+
+const UINT64_SIZE = 64;
+const UINT512_SIZE = 512;
+const MAX_UINT8 = 2 ** 8 - 1;
+const MAX_UINT64 = 2n ** 64n - 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_B32 = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAY5HFKQ';
+const ZERO_ADDRESS = Bytes.fromBase32(ZERO_ADDRESS_B32);
+/**
+"\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');
+
+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);
+    }
+}
+
+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);
+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();
+//TODO: handle arc4 types, bytes backed types
+const toBytes = (val) => {
+    const uint64Val = asMaybeUint64Cls(val);
+    if (uint64Val !== undefined) {
+        return uint64Val.toBytes().asAlgoTs();
+    }
+    const bytesVal = asMaybeBytesCls(val);
+    if (bytesVal !== undefined) {
+        return bytesVal.asAlgoTs();
+    }
+    const bigUintVal = asMaybeBigUintCls(val);
+    if (bigUintVal !== undefined) {
+        return bigUintVal.toBytes().asAlgoTs();
+    }
+    if (val instanceof BytesBackedCls) {
+        return val.bytes;
+    }
+    if (val instanceof Uint64BackedCls) {
+        return asUint64Cls(val.uint64).toBytes().asAlgoTs();
+    }
+    if (Array.isArray(val)) {
+        // This hack handles tuples/arrays of uint64 only
+        return val.reduce((acc, cur) => {
+            const uint64Val = asMaybeUint64Cls(cur);
+            if (!uint64Val) {
+                // TODO: support ABI tuple encoding
+                // internal.errors.internalError(`ABI tuple encoding not supported: ${nameOfType(val)}`)
+                return acc.concat(Bytes());
+            }
+            return acc.concat(toBytes(cur));
+        }, Bytes());
+    }
+    internal.errors.internalError(`Invalid type for bytes: ${nameOfType(val)}`);
+};
+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);
+};
+
+const ABI_LENGTH_SIZE = 2;
+const maxBigIntValue = (bitSize) => 2n ** BigInt(bitSize) - 1n;
+const maxBytesLength = (bitSize) => Math.floor(bitSize / BITS_IN_BYTE);
+const encodeLength = (length) => new internal.primitives.BytesCls(encodingUtil.bigIntToUint8Array(BigInt(length), ABI_LENGTH_SIZE));
+class UintNImpl extends UintN {
+    value;
+    bitSize;
+    typeInfo;
+    constructor(typeInfo, v) {
+        super();
+        this.typeInfo = typeof typeInfo === 'string' ? JSON.parse(typeInfo) : typeInfo;
+        this.bitSize = UintNImpl.getMaxBitsLength(this.typeInfo);
+        assert([8, 16, 32, 64, 128, 256, 512].includes(this.bitSize), `Invalid bit size ${this.bitSize}`);
+        const bigIntValue = asBigUintCls(v ?? 0n).valueOf();
+        const maxValue = maxBigIntValue(this.bitSize);
+        assert(bigIntValue <= maxValue, `expected value <= ${maxValue}, got: ${bigIntValue}`);
+        this.value = encodingUtil.bigIntToUint8Array(bigIntValue, maxBytesLength(this.bitSize));
+    }
+    get native() {
+        const bigIntValue = encodingUtil.uint8ArrayToBigInt(this.value);
+        return (this.bitSize <= UINT64_SIZE ? asUint64(bigIntValue) : asBigUint(bigIntValue));
+    }
+    get bytes() {
+        return Bytes(this.value);
+    }
+    equals(other) {
+        if (!(other instanceof UintNImpl) || JSON.stringify(this.typeInfo) !== JSON.stringify(other.typeInfo)) {
+            throw new internal.errors.CodeError(`Expected expression of type ${this.typeInfo.name}, got ${other.typeInfo.name}`);
+        }
+        return this.bytes.equals(other.bytes);
+    }
+    static fromBytesImpl(value, typeInfo, prefix = 'none') {
+        let bytesValue = asBytesCls(value);
+        if (prefix === 'log') {
+            assert(bytesValue.slice(0, 4).equals(ABI_RETURN_VALUE_LOG_PREFIX), 'ABI return prefix not found');
+            bytesValue = bytesValue.slice(4);
+        }
+        const result = new UintNImpl(typeInfo);
+        result.value = asUint8Array(bytesValue);
+        return result;
+    }
+    static getMaxBitsLength(typeInfo) {
+        return parseInt(typeInfo.genericArgs[0].name, 10);
+    }
+}
+const regExpNxM = (maxPrecision) => new RegExp(`^\\d*\\.?\\d{0,${maxPrecision}}$`);
+const trimTrailingDecimalZeros = (v) => v.replace(/(\d+\.\d*?)0+$/, '$1').replace(/\.$/, '');
+class UFixedNxMImpl extends UFixedNxM {
+    value;
+    bitSize;
+    precision;
+    typeInfo;
+    constructor(typeInfo, v) {
+        super(v);
+        this.typeInfo = typeof typeInfo === 'string' ? JSON.parse(typeInfo) : typeInfo;
+        const genericArgs = this.typeInfo.genericArgs;
+        this.bitSize = UFixedNxMImpl.getMaxBitsLength(this.typeInfo);
+        this.precision = parseInt(genericArgs.m.name, 10);
+        const trimmedValue = trimTrailingDecimalZeros(v);
+        assert(regExpNxM(this.precision).test(trimmedValue), `expected positive decimal literal with max of ${this.precision} decimal places`);
+        const bigIntValue = BigInt(trimmedValue.replace('.', ''));
+        const maxValue = maxBigIntValue(this.bitSize);
+        assert(bigIntValue <= maxValue, `expected value <= ${maxValue}, got: ${bigIntValue}`);
+        this.value = encodingUtil.bigIntToUint8Array(bigIntValue, maxBytesLength(this.bitSize));
+    }
+    get native() {
+        const bigIntValue = encodingUtil.uint8ArrayToBigInt(this.value);
+        return (this.bitSize <= UINT64_SIZE ? asUint64(bigIntValue) : asBigUint(bigIntValue));
+    }
+    get bytes() {
+        return Bytes(this.value);
+    }
+    equals(other) {
+        if (!(other instanceof UFixedNxMImpl) || JSON.stringify(this.typeInfo) !== JSON.stringify(other.typeInfo)) {
+            throw new internal.errors.CodeError(`Expected expression of type ${this.typeInfo.name}, got ${other.typeInfo.name}`);
+        }
+        return this.bytes.equals(other.bytes);
+    }
+    static fromBytesImpl(value, typeInfo, prefix = 'none') {
+        let bytesValue = asBytesCls(value);
+        if (prefix === 'log') {
+            assert(bytesValue.slice(0, 4).equals(ABI_RETURN_VALUE_LOG_PREFIX), 'ABI return prefix not found');
+            bytesValue = bytesValue.slice(4);
+        }
+        const result = new UFixedNxMImpl(typeInfo, '0.0');
+        result.value = asUint8Array(bytesValue);
+        return result;
+    }
+    static getMaxBitsLength(typeInfo) {
+        const genericArgs = typeInfo.genericArgs;
+        return parseInt(genericArgs.n.name, 10);
+    }
+}
+class ByteImpl extends Byte {
+    value;
+    constructor(typeInfo, v) {
+        super(v);
+        this.value = new UintNImpl(typeInfo, v);
+    }
+    get native() {
+        return this.value.native;
+    }
+    get bytes() {
+        return this.value.bytes;
+    }
+    equals(other) {
+        if (!(other instanceof ByteImpl) || JSON.stringify(this.value.typeInfo) !== JSON.stringify(other.value.typeInfo)) {
+            throw new internal.errors.CodeError(`Expected expression of type ${this.value.typeInfo.name}, got ${other.value.typeInfo.name}`);
+        }
+        return this.bytes.equals(other.bytes);
+    }
+    static fromBytesImpl(value, typeInfo, prefix = 'none') {
+        const uintNValue = UintNImpl.fromBytesImpl(value, typeInfo, prefix);
+        const result = new ByteImpl(typeInfo);
+        result.value = uintNValue;
+        return result;
+    }
+    static getMaxBitsLength(typeInfo) {
+        return UintNImpl.getMaxBitsLength(typeInfo);
+    }
+}
+class StrImpl extends Str {
+    value;
+    constructor(_typeInfo, s) {
+        super();
+        const bytesValue = asBytesCls(s ?? '');
+        const bytesLength = encodeLength(bytesValue.length.asNumber());
+        this.value = asUint8Array(bytesLength.concat(bytesValue));
+    }
+    get native() {
+        return encodingUtil.uint8ArrayToUtf8(this.value.slice(ABI_LENGTH_SIZE));
+    }
+    get bytes() {
+        return Bytes(this.value);
+    }
+    equals(other) {
+        if (!(other instanceof StrImpl)) {
+            throw new internal.errors.CodeError(`Expected expression of type Str, got ${other.constructor.name}`);
+        }
+        return this.bytes.equals(other.bytes);
+    }
+    static fromBytesImpl(value, typeInfo, prefix = 'none') {
+        let bytesValue = asBytesCls(value);
+        if (prefix === 'log') {
+            assert(bytesValue.slice(0, 4).equals(ABI_RETURN_VALUE_LOG_PREFIX), 'ABI return prefix not found');
+            bytesValue = bytesValue.slice(4);
+        }
+        const result = new StrImpl(typeInfo);
+        result.value = asUint8Array(bytesValue);
+        return result;
+    }
+}
+const TRUE_BIGINT_VALUE = 128n;
+const FALSE_BIGINT_VALUE = 0n;
+class BoolImpl extends Bool {
+    value;
+    constructor(_typeInfo, v) {
+        super(v);
+        this.value = encodingUtil.bigIntToUint8Array(v ? TRUE_BIGINT_VALUE : FALSE_BIGINT_VALUE, 1);
+    }
+    get native() {
+        return encodingUtil.uint8ArrayToBigInt(this.value) === TRUE_BIGINT_VALUE;
+    }
+    equals(other) {
+        if (!(other instanceof BoolImpl)) {
+            throw new internal.errors.CodeError(`Expected expression of type Bool, got ${other.constructor.name}`);
+        }
+        return this.bytes.equals(other.bytes);
+    }
+    get bytes() {
+        return Bytes(this.value);
+    }
+    static fromBytesImpl(value, typeInfo, prefix = 'none') {
+        let bytesValue = asBytesCls(value);
+        if (prefix === 'log') {
+            assert(bytesValue.slice(0, 4).equals(ABI_RETURN_VALUE_LOG_PREFIX), 'ABI return prefix not found');
+            bytesValue = bytesValue.slice(4);
+        }
+        const result = new BoolImpl(typeInfo);
+        result.value = asUint8Array(bytesValue);
+        return result;
+    }
+}
+const areAllARC4Encoded = (items) => items.every((item) => item instanceof ARC4Encoded);
+const checkItemTypeName = (type, value) => {
+    const typeName = trimGenericTypeName(type.name);
+    const validTypeNames = [typeName, `${typeName}Impl`];
+    assert(validTypeNames.includes(value.constructor.name), `item must be of type ${typeName}, not ${value.constructor.name}`);
+};
+const arrayProxyHandler = () => ({
+    get(target, prop) {
+        const idx = prop ? parseInt(prop.toString(), 10) : NaN;
+        if (!isNaN(idx)) {
+            if (idx < target.items.length)
+                return target.items[idx];
+            internal.errors.avmError('Index out of bounds');
+        }
+        else if (prop === Symbol.iterator) {
+            return target.items[Symbol.iterator].bind(target.items);
+        }
+        else if (prop === 'entries') {
+            return target.items.entries.bind(target.items);
+        }
+        else if (prop === 'at') {
+            return (index) => {
+                return internal.primitives.arrayUtil.arrayAt(target.items, index);
+            };
+        }
+        return Reflect.get(target, prop);
+    },
+    set(target, prop, value) {
+        const idx = prop ? parseInt(prop.toString(), 10) : NaN;
+        if (!isNaN(idx)) {
+            if (idx < target.items.length) {
+                target.setItem(idx, value);
+                return true;
+            }
+            internal.errors.avmError('Index out of bounds');
+        }
+        return Reflect.set(target, prop, value);
+    },
+});
+class StaticArrayImpl extends StaticArray {
+    value;
+    uint8ArrayValue;
+    typeInfo;
+    size;
+    genericArgs;
+    constructor(typeInfo, ...items) {
+        super(...items);
+        this.typeInfo = typeof typeInfo === 'string' ? JSON.parse(typeInfo) : typeInfo;
+        this.genericArgs = this.typeInfo.genericArgs;
+        this.size = parseInt(this.genericArgs.size.name, 10);
+        if (items.length && items.length !== this.size) {
+            throw new internal.errors.CodeError(`expected ${this.size} items, not ${items.length}`);
+        }
+        assert(areAllARC4Encoded(items), 'expected ARC4 type');
+        items.forEach((item) => {
+            checkItemTypeName(this.genericArgs.elementType, item);
+        });
+        this.value = items.length ? items : undefined;
+        return new Proxy(this, arrayProxyHandler());
+    }
+    get bytes() {
+        return Bytes(this.uint8ArrayValue ?? encode(this.items));
+    }
+    equals(other) {
+        if (!(other instanceof StaticArrayImpl) || JSON.stringify(this.typeInfo) !== JSON.stringify(other.typeInfo)) {
+            throw new internal.errors.CodeError(`Expected expression of type ${this.typeInfo.name}, got ${other.typeInfo.name}`);
+        }
+        return this.bytes.equals(other.bytes);
+    }
+    get length() {
+        return this.size;
+    }
+    get items() {
+        if (this.uint8ArrayValue) {
+            const childTypes = Array(this.size).fill(this.genericArgs.elementType);
+            this.value = decode(this.uint8ArrayValue, childTypes);
+            this.uint8ArrayValue = undefined;
+            return this.value;
+        }
+        else if (this.value) {
+            this.uint8ArrayValue = undefined;
+            return this.value;
+        }
+        throw new internal.errors.CodeError('value is not set');
+    }
+    setItem(index, value) {
+        this.items[index] = value;
+    }
+    copy() {
+        return StaticArrayImpl.fromBytesImpl(this.bytes, JSON.stringify(this.typeInfo));
+    }
+    static fromBytesImpl(value, typeInfo, prefix = 'none') {
+        let bytesValue = asBytesCls(value);
+        if (prefix === 'log') {
+            assert(bytesValue.slice(0, 4).equals(ABI_RETURN_VALUE_LOG_PREFIX), 'ABI return prefix not found');
+            bytesValue = bytesValue.slice(4);
+        }
+        const result = new StaticArrayImpl(typeInfo);
+        result.uint8ArrayValue = asUint8Array(bytesValue);
+        return result;
+    }
+    static getMaxBytesLength(typeInfo) {
+        const genericArgs = typeInfo.genericArgs;
+        const arraySize = parseInt(genericArgs.size.name, 10);
+        const childTypes = Array(arraySize).fill(genericArgs.elementType);
+        let i = 0;
+        let size = 0;
+        if (genericArgs.elementType.name === 'Bool') {
+            while (i < childTypes.length) {
+                const after = findBoolTypes(childTypes, i, 1);
+                const boolNum = after + 1;
+                size += Math.floor(boolNum / BITS_IN_BYTE);
+                size += boolNum % BITS_IN_BYTE ? 1 : 0;
+                i += after + 1;
+            }
+        }
+        else {
+            size = getMaxLengthOfStaticContentType(genericArgs.elementType) * arraySize;
+        }
+        return size;
+    }
+}
+class AddressImpl extends Address {
+    typeInfo;
+    value;
+    constructor(typeInfo, value) {
+        super(value);
+        let uint8ArrayValue;
+        if (value === undefined) {
+            uint8ArrayValue = new Uint8Array(32);
+        }
+        else if (typeof value === 'string') {
+            uint8ArrayValue = decodeAddress(value).publicKey;
+        }
+        else if (internal.primitives.isBytes(value)) {
+            uint8ArrayValue = internal.primitives.getUint8Array(value);
+        }
+        else {
+            uint8ArrayValue = internal.primitives.getUint8Array(value.bytes);
+        }
+        internal.errors.avmInvariant(uint8ArrayValue.length === 32, 'Addresses should be 32 bytes');
+        this.value = StaticArrayImpl.fromBytesImpl(uint8ArrayValue, typeInfo);
+        this.typeInfo = typeof typeInfo === 'string' ? JSON.parse(typeInfo) : typeInfo;
+        return new Proxy(this, arrayProxyHandler());
+    }
+    get bytes() {
+        return this.value.bytes;
+    }
+    equals(other) {
+        if (!(other instanceof AddressImpl) || JSON.stringify(this.typeInfo) !== JSON.stringify(other.typeInfo)) {
+            throw new internal.errors.CodeError(`Expected expression of type ${this.typeInfo.name}, got ${other.typeInfo.name}`);
+        }
+        return this.bytes.equals(other.bytes);
+    }
+    get length() {
+        return 32;
+    }
+    get native() {
+        return Account(this.value.bytes);
+    }
+    get items() {
+        return this.value.items;
+    }
+    setItem(_index, _value) {
+        throw new internal.errors.CodeError('Address is immutable');
+    }
+    static fromBytesImpl(value, typeInfo, prefix = 'none') {
+        const staticArrayValue = StaticArrayImpl.fromBytesImpl(value, typeInfo, prefix);
+        const result = new AddressImpl(typeInfo);
+        result.value = staticArrayValue;
+        return result;
+    }
+    static getMaxBytesLength(typeInfo) {
+        return StaticArrayImpl.getMaxBytesLength(typeInfo);
+    }
+}
+const readLength = (value) => {
+    const length = Number(encodingUtil.uint8ArrayToBigInt(value.slice(0, ABI_LENGTH_SIZE)));
+    const data = value.slice(ABI_LENGTH_SIZE);
+    return [length, data];
+};
+class DynamicArrayImpl extends DynamicArray {
+    value;
+    uint8ArrayValue;
+    typeInfo;
+    genericArgs;
+    constructor(typeInfo, ...items) {
+        super(...items);
+        this.typeInfo = typeof typeInfo === 'string' ? JSON.parse(typeInfo) : typeInfo;
+        this.genericArgs = this.typeInfo.genericArgs;
+        assert(areAllARC4Encoded(items), 'expected ARC4 type');
+        items.forEach((item) => {
+            checkItemTypeName(this.genericArgs.elementType, item);
+        });
+        this.value = items;
+        return new Proxy(this, arrayProxyHandler());
+    }
+    get bytes() {
+        return Bytes(this.uint8ArrayValue ?? this.encodeWithLength(this.items));
+    }
+    equals(other) {
+        if (!(other instanceof DynamicArrayImpl) || JSON.stringify(this.typeInfo) !== JSON.stringify(other.typeInfo)) {
+            throw new internal.errors.CodeError(`Expected expression of type ${this.typeInfo.name}, got ${other.typeInfo.name}`);
+        }
+        return this.bytes.equals(other.bytes);
+    }
+    get length() {
+        return this.items.length;
+    }
+    get items() {
+        if (this.uint8ArrayValue) {
+            const [length, data] = readLength(this.uint8ArrayValue);
+            const childTypes = Array(length).fill(this.genericArgs.elementType);
+            this.value = decode(data, childTypes);
+            this.uint8ArrayValue = undefined;
+            return this.value;
+        }
+        else if (this.value) {
+            this.uint8ArrayValue = undefined;
+            return this.value;
+        }
+        throw new internal.errors.CodeError('value is not set');
+    }
+    setItem(index, value) {
+        this.items[index] = value;
+    }
+    copy() {
+        return DynamicArrayImpl.fromBytesImpl(this.bytes, JSON.stringify(this.typeInfo));
+    }
+    push(...values) {
+        const items = this.items;
+        items.push(...values);
+    }
+    pop() {
+        const items = this.items;
+        const popped = items.pop();
+        if (popped === undefined)
+            internal.errors.avmError('The array is empty');
+        return popped;
+    }
+    static fromBytesImpl(value, typeInfo, prefix = 'none') {
+        let bytesValue = asBytesCls(value);
+        if (prefix === 'log') {
+            assert(bytesValue.slice(0, 4).equals(ABI_RETURN_VALUE_LOG_PREFIX), 'ABI return prefix not found');
+            bytesValue = bytesValue.slice(4);
+        }
+        const result = new DynamicArrayImpl(typeInfo);
+        result.uint8ArrayValue = asUint8Array(bytesValue);
+        return result;
+    }
+    encodeWithLength(items) {
+        return conactUint8Arrays(encodeLength(items.length).asUint8Array(), encode(items));
+    }
+}
+class TupleImpl extends Tuple {
+    value;
+    uint8ArrayValue;
+    typeInfo;
+    genericArgs;
+    constructor(typeInfo, ...items) {
+        super(...items);
+        this.typeInfo = typeof typeInfo === 'string' ? JSON.parse(typeInfo) : typeInfo;
+        this.genericArgs = Object.values(this.typeInfo.genericArgs);
+        assert(areAllARC4Encoded(items), 'expected ARC4 type');
+        items.forEach((item, index) => {
+            checkItemTypeName(this.genericArgs[index], item);
+        });
+        this.value = items.length ? items : undefined;
+    }
+    get bytes() {
+        return Bytes(this.uint8ArrayValue ?? encode(this.items));
+    }
+    equals(other) {
+        if (!(other instanceof TupleImpl) || JSON.stringify(this.typeInfo) !== JSON.stringify(other.typeInfo)) {
+            throw new internal.errors.CodeError(`Expected expression of type ${this.typeInfo.name}, got ${other.typeInfo.name}`);
+        }
+        return this.bytes.equals(other.bytes);
+    }
+    get length() {
+        return this.items.length;
+    }
+    get native() {
+        return this.items;
+    }
+    at(index) {
+        return this.items[index];
+    }
+    get items() {
+        if (this.uint8ArrayValue) {
+            this.value = decode(this.uint8ArrayValue, this.genericArgs);
+            this.uint8ArrayValue = undefined;
+            return this.value;
+        }
+        else if (this.value) {
+            this.uint8ArrayValue = undefined;
+            return this.value;
+        }
+        throw new internal.errors.CodeError('value is not set');
+    }
+    static fromBytesImpl(value, typeInfo, prefix = 'none') {
+        let bytesValue = asBytesCls(value);
+        if (prefix === 'log') {
+            assert(bytesValue.slice(0, 4).equals(ABI_RETURN_VALUE_LOG_PREFIX), 'ABI return prefix not found');
+            bytesValue = bytesValue.slice(4);
+        }
+        const result = new TupleImpl(typeInfo);
+        result.uint8ArrayValue = asUint8Array(bytesValue);
+        return result;
+    }
+    static getMaxBytesLength(typeInfo) {
+        const genericArgs = Object.values(typeInfo.genericArgs);
+        let i = 0;
+        let size = 0;
+        while (i < genericArgs.length) {
+            const childType = genericArgs[i];
+            if (childType.name === 'Bool') {
+                const after = findBoolTypes(genericArgs, i, 1);
+                const boolNum = after + 1;
+                size += Math.floor(boolNum / BITS_IN_BYTE);
+                size += boolNum % BITS_IN_BYTE ? 1 : 0;
+                i += after;
+            }
+            else {
+                size += getMaxLengthOfStaticContentType(childType);
+            }
+            i += 1;
+        }
+        return size;
+    }
+}
+class StructImpl extends Struct {
+    uint8ArrayValue;
+    typeInfo;
+    genericArgs;
+    constructor(typeInfo, value = {}) {
+        super(value);
+        this.typeInfo = typeof typeInfo === 'string' ? JSON.parse(typeInfo) : typeInfo;
+        this.genericArgs = this.typeInfo.genericArgs;
+        Object.keys(this.genericArgs).forEach((key) => {
+            Object.defineProperty(this, key, {
+                value: value[key],
+                writable: true,
+                enumerable: true,
+            });
+        });
+        return new Proxy(this, {
+            get(target, prop) {
+                const originalValue = Reflect.get(target, prop);
+                if (originalValue === undefined && target.uint8ArrayValue && Object.keys(target.genericArgs).includes(prop.toString())) {
+                    return target.items[prop.toString()];
+                }
+                return originalValue;
+            },
+            set(target, prop, value) {
+                if (target.uint8ArrayValue && Object.keys(target.genericArgs).includes(prop.toString())) {
+                    target.decodeAsProperties();
+                }
+                return Reflect.set(target, prop, value);
+            },
+        });
+    }
+    get bytes() {
+        return Bytes(this.uint8ArrayValue ?? encode(Object.values(this.items)));
+    }
+    get items() {
+        this.decodeAsProperties();
+        const result = {};
+        Object.keys(this.genericArgs).forEach((key) => {
+            result[key] = this[key];
+        });
+        return result;
+    }
+    decodeAsProperties() {
+        if (this.uint8ArrayValue) {
+            const values = decode(this.uint8ArrayValue, Object.values(this.genericArgs));
+            Object.keys(this.genericArgs).forEach((key, index) => {
+                this[key] = values[index];
+            });
+            this.uint8ArrayValue = undefined;
+        }
+    }
+    static fromBytesImpl(value, typeInfo, prefix = 'none') {
+        let bytesValue = asBytesCls(value);
+        if (prefix === 'log') {
+            assert(bytesValue.slice(0, 4).equals(ABI_RETURN_VALUE_LOG_PREFIX), 'ABI return prefix not found');
+            bytesValue = bytesValue.slice(4);
+        }
+        const result = new StructImpl(typeInfo);
+        result.uint8ArrayValue = asUint8Array(bytesValue);
+        return result;
+    }
+}
+class DynamicBytesImpl extends DynamicBytes {
+    typeInfo;
+    value;
+    constructor(typeInfo, value) {
+        super(value);
+        const uint8ArrayValue = conactUint8Arrays(encodeLength(value?.length ?? 0).asUint8Array(), asUint8Array(value ?? new Uint8Array()));
+        this.value = DynamicArrayImpl.fromBytesImpl(uint8ArrayValue, typeInfo);
+        this.typeInfo = typeof typeInfo === 'string' ? JSON.parse(typeInfo) : typeInfo;
+        return new Proxy(this, arrayProxyHandler());
+    }
+    get bytes() {
+        return this.value.bytes;
+    }
+    equals(other) {
+        if (!(other instanceof DynamicBytesImpl) || JSON.stringify(this.typeInfo) !== JSON.stringify(other.typeInfo)) {
+            throw new internal.errors.CodeError(`Expected expression of type ${this.typeInfo.name}, got ${other.typeInfo.name}`);
+        }
+        return this.bytes.equals(other.bytes);
+    }
+    get length() {
+        return this.value.length;
+    }
+    get native() {
+        return this.value.bytes.slice(ABI_LENGTH_SIZE);
+    }
+    get items() {
+        return this.value.items;
+    }
+    setItem(_index, _value) {
+        throw new internal.errors.CodeError('DynamicBytes is immutable');
+    }
+    static fromBytesImpl(value, typeInfo, prefix = 'none') {
+        const dynamicArrayValue = DynamicArrayImpl.fromBytesImpl(value, typeInfo, prefix);
+        const result = new DynamicBytesImpl(typeInfo);
+        result.value = dynamicArrayValue;
+        return result;
+    }
+}
+class StaticBytesImpl extends StaticBytes {
+    value;
+    typeInfo;
+    constructor(typeInfo, value) {
+        super(value);
+        const uint8ArrayValue = asUint8Array(value ?? new Uint8Array());
+        this.value = StaticArrayImpl.fromBytesImpl(uint8ArrayValue, typeInfo);
+        this.typeInfo = typeof typeInfo === 'string' ? JSON.parse(typeInfo) : typeInfo;
+        return new Proxy(this, arrayProxyHandler());
+    }
+    get bytes() {
+        return this.value.bytes;
+    }
+    equals(other) {
+        if (!(other instanceof StaticBytesImpl) || JSON.stringify(this.typeInfo) !== JSON.stringify(other.typeInfo)) {
+            throw new internal.errors.CodeError(`Expected expression of type ${this.typeInfo.name}, got ${other.typeInfo.name}`);
+        }
+        return this.bytes.equals(other.bytes);
+    }
+    get length() {
+        return this.value.length;
+    }
+    get native() {
+        return this.value.bytes;
+    }
+    get items() {
+        return this.value.items;
+    }
+    setItem(_index, _value) {
+        throw new internal.errors.CodeError('StaticBytes is immutable');
+    }
+    static fromBytesImpl(value, typeInfo, prefix = 'none') {
+        const staticArrayValue = StaticArrayImpl.fromBytesImpl(value, typeInfo, prefix);
+        const result = new StaticBytesImpl(typeInfo);
+        result.value = staticArrayValue;
+        return result;
+    }
+    static getMaxBytesLength(typeInfo) {
+        return StaticArrayImpl.getMaxBytesLength(typeInfo);
+    }
+}
+const decode = (value, childTypes) => {
+    let i = 0;
+    let arrayIndex = 0;
+    const valuePartitions = [];
+    const dynamicSegments = []; // Store the start and end of a dynamic element
+    while (i < childTypes.length) {
+        const childType = childTypes[i];
+        if (holdsDynamicLengthContent(childType)) {
+            // Decode the size of the dynamic element
+            const dynamicIndex = uint8ArrayToNumber(value.slice(arrayIndex, arrayIndex + ABI_LENGTH_SIZE));
+            if (dynamicSegments.length) {
+                dynamicSegments.at(-1)[1] = dynamicIndex;
+            }
+            // Since we do not know where the current dynamic element ends,
+            // put a placeholder and update later
+            dynamicSegments.push([dynamicIndex, -1]);
+            valuePartitions.push(new Uint8Array());
+            arrayIndex += ABI_LENGTH_SIZE;
+        }
+        else if (childType.name === 'Bool') {
+            const before = findBoolTypes(childTypes, i, -1);
+            let after = findBoolTypes(childTypes, i, 1);
+            if (before % 8 != 0) {
+                throw new internal.errors.CodeError('"expected before index should have number of bool mod 8 equal 0"');
+            }
+            after = Math.min(7, after);
+            const bits = uint8ArrayToNumber(value.slice(arrayIndex, arrayIndex + 1));
+            Array(after + 1)
+                .fill(0)
+                .forEach((_, j) => {
+                const mask = 128 >> j;
+                valuePartitions.push(mask & bits ? encodingUtil.bigIntToUint8Array(TRUE_BIGINT_VALUE) : encodingUtil.bigIntToUint8Array(FALSE_BIGINT_VALUE));
+            });
+            i += after;
+            arrayIndex += 1;
+        }
+        else {
+            const currLen = getMaxLengthOfStaticContentType(childType);
+            valuePartitions.push(value.slice(arrayIndex, arrayIndex + currLen));
+            arrayIndex += currLen;
+        }
+        if (arrayIndex >= value.length && i != childTypes.length - 1) {
+            throw new internal.errors.CodeError('input string is not long enough to be decoded');
+        }
+        i += 1;
+    }
+    if (dynamicSegments.length > 0) {
+        dynamicSegments.at(-1)[1] = value.length;
+        arrayIndex = value.length;
+    }
+    if (arrayIndex < value.length) {
+        throw new internal.errors.CodeError('input string was not fully consumed');
+    }
+    // Check dynamic element partitions
+    let segmentIndex = 0;
+    childTypes.forEach((childType, index) => {
+        if (holdsDynamicLengthContent(childType)) {
+            const [segmentStart, segmentEnd] = dynamicSegments[segmentIndex];
+            valuePartitions[index] = value.slice(segmentStart, segmentEnd);
+            segmentIndex += 1;
+        }
+    });
+    const values = [];
+    childTypes.forEach((childType, index) => {
+        values.push(getArc4Encoder(childType)(valuePartitions[index], childType));
+    });
+    return values;
+};
+const findBoolTypes = (values, index, delta) => {
+    // Helper function to find consecutive booleans from current index in a tuple.
+    let until = 0;
+    const length = values.length;
+    while (true) {
+        const curr = index + delta * until;
+        if (values[curr].name === 'Bool') {
+            if ((curr != length - 1 && delta > 0) || (curr > 0 && delta < 0)) {
+                until += 1;
+            }
+            else {
+                break;
+            }
+        }
+        else {
+            until -= 1;
+            break;
+        }
+    }
+    return until;
+};
+const getMaxLengthOfStaticContentType = (type) => {
+    switch (trimGenericTypeName(type.name)) {
+        case 'Address':
+            return AddressImpl.getMaxBytesLength(type);
+        case 'Byte':
+            return ByteImpl.getMaxBitsLength(type) / BITS_IN_BYTE;
+        case 'UintN':
+            return UintNImpl.getMaxBitsLength(type) / BITS_IN_BYTE;
+        case 'UFixedNxM':
+            return UFixedNxMImpl.getMaxBitsLength(type) / BITS_IN_BYTE;
+        case 'StaticArray':
+            return StaticArrayImpl.getMaxBytesLength(type);
+        case 'StaticBytes':
+            return StaticBytesImpl.getMaxBytesLength(type);
+        case 'Tuple':
+            return TupleImpl.getMaxBytesLength(type);
+    }
+    throw new internal.errors.CodeError(`unsupported type ${type.name}`);
+};
+const encode = (values) => {
+    const length = values.length;
+    const heads = [];
+    const tails = [];
+    const dynamicLengthTypeIndex = [];
+    let i = 0;
+    const valuesLengthBytes = values instanceof DynamicArray ? encodeLength(length).asUint8Array() : new Uint8Array();
+    while (i < length) {
+        const value = values[i];
+        assert(value instanceof ARC4Encoded, `expected ARC4 type ${value.constructor.name}`);
+        dynamicLengthTypeIndex.push(isDynamicLengthType(value));
+        if (dynamicLengthTypeIndex.at(-1)) {
+            heads.push(asUint8Array(Bytes.fromHex('0000')));
+            tails.push(asUint8Array(value.bytes));
+        }
+        else {
+            if (value instanceof Bool) {
+                const before = findBool(values, i, -1);
+                let after = findBool(values, i, 1);
+                if (before % 8 != 0) {
+                    throw new internal.errors.CodeError('"expected before index should have number of bool mod 8 equal 0"');
+                }
+                after = Math.min(7, after);
+                const consecutiveBools = values.slice(i, i + after + 1);
+                const compressedNumber = compressMultipleBool(consecutiveBools);
+                heads.push(new Uint8Array([compressedNumber]));
+                i += after;
+            }
+            else {
+                heads.push(asUint8Array(value.bytes));
+            }
+            tails.push(new Uint8Array());
+        }
+        i += 1;
+    }
+    // Adjust heads for dynamic types
+    let headLength = 0;
+    heads.forEach((head) => {
+        // If the element is not a placeholder, append the length of the element
+        headLength += head.length;
+    });
+    // Correctly encode dynamic types and replace placeholder
+    let tailCurrLength = 0;
+    for (let i = 0; i < heads.length; i++) {
+        if (dynamicLengthTypeIndex[i]) {
+            const headValue = headLength + tailCurrLength;
+            heads[i] = asUint8Array(encodeLength(headValue));
+        }
+        tailCurrLength += tails[i].length;
+    }
+    return conactUint8Arrays(valuesLengthBytes, ...heads, ...tails);
+};
+const findBool = (values, index, delta) => {
+    let until = 0;
+    const length = values.length;
+    while (true) {
+        const curr = index + delta * until;
+        if (values[curr] instanceof Bool) {
+            if ((curr !== length - 1 && delta > 0) || (curr > 0 && delta < 0)) {
+                until += 1;
+            }
+            else {
+                break;
+            }
+        }
+        else {
+            until -= 1;
+            break;
+        }
+    }
+    return until;
+};
+const compressMultipleBool = (values) => {
+    let result = 0;
+    if (values.length > 8) {
+        throw new Error('length of list should not be greater than 8');
+    }
+    for (let i = 0; i < values.length; i++) {
+        const value = values[i];
+        if (value.native) {
+            result |= 1 << (7 - i);
+        }
+    }
+    return result;
+};
+const trimGenericTypeName = (typeName) => typeName.replace(/<.*>/, '');
+const isDynamicLengthType = (value) => value instanceof StrImpl ||
+    (value instanceof StaticArrayImpl && holdsDynamicLengthContent(value)) ||
+    (value instanceof TupleImpl && value.genericArgs.some(holdsDynamicLengthContent)) ||
+    (value instanceof StructImpl && Object.values(value.genericArgs).some(holdsDynamicLengthContent)) ||
+    value instanceof DynamicArrayImpl ||
+    value instanceof DynamicBytesImpl;
+const holdsDynamicLengthContent = (value) => {
+    const itemTypeName = trimGenericTypeName(value instanceof StaticArrayImpl || value instanceof DynamicArrayImpl ? value.genericArgs.elementType.name : value.name);
+    return (itemTypeName === 'Str' ||
+        itemTypeName === 'DynamicArray' ||
+        itemTypeName === 'DynamicBytes' ||
+        (itemTypeName === 'StaticArray' &&
+            holdsDynamicLengthContent(value.genericArgs.elementType)) ||
+        ((itemTypeName === 'Tuple' || itemTypeName === 'Struct') &&
+            Object.values(value.genericArgs).some(holdsDynamicLengthContent)));
+};
+function interpretAsArc4Impl(typeInfoString, bytes, prefix = 'none') {
+    const typeInfo = JSON.parse(typeInfoString);
+    return getArc4Encoder(typeInfo)(bytes, typeInfo, prefix);
+}
+const arc4Encoders = {
+    Address: AddressImpl.fromBytesImpl,
+    Bool: BoolImpl.fromBytesImpl,
+    Byte: ByteImpl.fromBytesImpl,
+    Str: StrImpl.fromBytesImpl,
+    'UintN<.*>': UintNImpl.fromBytesImpl,
+    'UFixedNxM<.*>': UFixedNxMImpl.fromBytesImpl,
+    'StaticArray<.*>': StaticArrayImpl.fromBytesImpl,
+    'DynamicArray<.*>': DynamicArrayImpl.fromBytesImpl,
+    Tuple: TupleImpl.fromBytesImpl,
+    Struct: StructImpl.fromBytesImpl,
+    DynamicBytes: DynamicBytesImpl.fromBytesImpl,
+    'StaticBytes<.*>': StaticBytesImpl.fromBytesImpl,
+};
+const getArc4Encoder = (typeInfo, encoders) => {
+    const encoder = Object.entries(encoders ?? arc4Encoders).find(([k, _]) => new RegExp(`^${k}$`, 'i').test(typeInfo.name))?.[1];
+    if (!encoder) {
+        throw new Error(`No encoder found for type ${typeInfo.name}`);
+    }
+    return encoder;
+};
+
+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')
+        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 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 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 $, ALWAYS_APPROVE_TEAL_PROGRAM as A, BITS_IN_BYTE as B, ABI_RETURN_VALUE_LOG_PREFIX as C, DEFAULT_ACCOUNT_MIN_BALANCE as D, getRandomBytes as E, getArc4Encoder as F, arc4Encoders as G, getGenericTypeInfo as H, getAbiMetadata as I, iterBigInt as J, getRandomBigInt as K, LOGIC_DATA_PREFIX as L, MAX_BOX_SIZE as M, captureMethodConfig as N, switchableValue as O, binaryOp as P, unaryOp as Q, captureGenericTypeInfo as R, attachAbiMetadata as S, UintNImpl as T, UINT64_SIZE as U, UFixedNxMImpl as V, ByteImpl as W, StrImpl as X, BoolImpl as Y, ZERO_ADDRESS as Z, StaticArrayImpl as _, asMaybeUint64Cls as a, DynamicArrayImpl as a0, TupleImpl as a1, StructImpl as a2, DynamicBytesImpl as a3, StaticBytesImpl as a4, interpretAsArc4Impl as a5, asUint64 as b, asBytes as c, asNumber as d, asBytesCls as e, asUint8Array as f, conactUint8Arrays as g, asBigInt as h, getObjectReference as i, MIN_TXN_FEE as j, DEFAULT_MAX_TXN_LIFE as k, DEFAULT_ASSET_CREATE_MIN_BALANCE as l, DEFAULT_ASSET_OPT_IN_MIN_BALANCE as m, DEFAULT_GLOBAL_GENESIS_HASH as n, asUint64Cls as o, asMaybeBytesCls as p, asBigUint as q, MAX_BYTES_SIZE as r, MAX_UINT8 as s, toBytes as t, binaryStringToBytes as u, MAX_UINT64 as v, Uint64BackedCls as w, BytesBackedCls as x, combineIntoMaxBytePages as y, MAX_ITEMS_IN_LOG as z };
+//# sourceMappingURL=runtime-helpers-DlIX78iw.js.map