@algorandfoundation/algorand-typescript 0.0.1-alpha.1 → 0.0.1-alpha.10

package/arc4/index.mjs

@@ -0,0 +1,5 @@
+export { w as Address, t as Bool, s as Byte, C as Contract, D as DynamicArray, n as OnCompleteAction, v as StaticArray, S as Str, T as Tuple, r as UFixedNxM, q as UintN, g as abimethod, o as baremethod } from '../index-DffKkMrz.js';
+import '../execution-context-BznYSiE4.js';
+import 'node:buffer';
+import 'node:util';
+//# sourceMappingURL=index.mjs.map

package/arc4/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;"}

package/execution-context-BznYSiE4.js

@@ -0,0 +1,20 @@
+const ctxMgr = {
+    set instance(ctx) {
+        const instance = global.puyaTsExecutionContext;
+        if (instance != undefined)
+            throw new Error('Execution context has already been set');
+        global.puyaTsExecutionContext = ctx;
+    },
+    get instance() {
+        const instance = global.puyaTsExecutionContext;
+        if (instance == undefined)
+            throw new Error('No execution context has been set');
+        return instance;
+    },
+    reset() {
+        global.puyaTsExecutionContext = undefined;
+    },
+};
+
+export { ctxMgr as c };
+//# sourceMappingURL=execution-context-BznYSiE4.js.map

package/execution-context-BznYSiE4.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"execution-context-BznYSiE4.js","sources":["../src/execution-context.ts"],"sourcesContent":["import { Contract, gtxn, itxn } from '.'\nimport { AbiMethodConfig, BareMethodConfig } from './arc4'\nimport { OpsNamespace } from './op-types'\nimport { bytes, uint64 } from './primitives'\nimport { Account, Application, Asset } from './reference'\n\nexport type ExecutionContext = {\n  log(value: bytes): void\n  application(id?: uint64): Application\n  asset(id?: uint64): Asset\n  account(address?: bytes): Account\n  op: Partial<OpsNamespace>\n  abiMetadata: {\n    captureMethodConfig<T extends Contract>(contract: T, methodName: string, config?: AbiMethodConfig<T> | BareMethodConfig): void\n  }\n  gtxn: {\n    Transaction: typeof gtxn.Transaction\n    PaymentTxn: typeof gtxn.PaymentTxn\n    KeyRegistrationTxn: typeof gtxn.KeyRegistrationTxn\n    AssetConfigTxn: typeof gtxn.AssetConfigTxn\n    AssetTransferTxn: typeof gtxn.AssetTransferTxn\n    AssetFreezeTxn: typeof gtxn.AssetFreezeTxn\n    ApplicationTxn: typeof gtxn.ApplicationTxn\n  }\n  itxn: {\n    submitGroup: typeof itxn.submitGroup\n    payment: typeof itxn.payment\n    keyRegistration: typeof itxn.keyRegistration\n    assetConfig: typeof itxn.assetConfig\n    assetTransfer: typeof itxn.assetTransfer\n    assetFreeze: typeof itxn.assetFreeze\n    applicationCall: typeof itxn.applicationCall\n  }\n}\n\ndeclare global {\n  // eslint-disable-next-line no-var\n  var puyaTsExecutionContext: ExecutionContext | undefined\n}\n\nexport const ctxMgr = {\n  set instance(ctx: ExecutionContext) {\n    const instance = global.puyaTsExecutionContext\n    if (instance != undefined) throw new Error('Execution context has already been set')\n    global.puyaTsExecutionContext = ctx\n  },\n  get instance() {\n    const instance = global.puyaTsExecutionContext\n    if (instance == undefined) throw new Error('No execution context has been set')\n    return instance\n  },\n  reset() {\n    global.puyaTsExecutionContext = undefined\n  },\n}\n"],"names":[],"mappings":"AAwCa,MAAA,MAAM,GAAG;IACpB,IAAI,QAAQ,CAAC,GAAqB,EAAA;AAChC,QAAA,MAAM,QAAQ,GAAG,MAAM,CAAC,sBAAsB,CAAA;QAC9C,IAAI,QAAQ,IAAI,SAAS;AAAE,YAAA,MAAM,IAAI,KAAK,CAAC,wCAAwC,CAAC,CAAA;AACpF,QAAA,MAAM,CAAC,sBAAsB,GAAG,GAAG,CAAA;KACpC;AACD,IAAA,IAAI,QAAQ,GAAA;AACV,QAAA,MAAM,QAAQ,GAAG,MAAM,CAAC,sBAAsB,CAAA;QAC9C,IAAI,QAAQ,IAAI,SAAS;AAAE,YAAA,MAAM,IAAI,KAAK,CAAC,mCAAmC,CAAC,CAAA;AAC/E,QAAA,OAAO,QAAQ,CAAA;KAChB;IACD,KAAK,GAAA;AACH,QAAA,MAAM,CAAC,sBAAsB,GAAG,SAAS,CAAA;KAC1C;;;;;"}

package/impl/encoding-util.d.ts

@@ -1,4 +1,6 @@
 export declare const uint8ArrayToBigInt: (v: Uint8Array) => bigint;
+export declare const hexToUint8Array: (value: string) => Uint8Array;
+export declare const base64ToUint8Array: (value: string) => Uint8Array;
 export declare const bigIntToUint8Array: (val: bigint, fixedSize?: number | "dynamic") => Uint8Array;
 export declare const utf8ToUint8Array: (value: string) => Uint8Array;
 export declare const uint8ArrayToUtf8: (value: Uint8Array) => string;

package/impl/errors.d.ts

@@ -6,6 +6,7 @@ export declare class AvmError extends Error {
     constructor(message: string);
 }
 export declare function avmError(message: string): never;
+export declare function avmInvariant(condition: unknown, message: string): asserts condition;
 /**
  * Raised when an assertion fails
  */

package/impl/primitives.d.ts

@@ -7,33 +7,35 @@ export declare function toExternalValue(val: biguint): bigint;
 export declare function toExternalValue(val: bytes): Uint8Array;
 export declare function toExternalValue(val: string): string;
 export declare const toBytes: (val: unknown) => bytes;
+/**
+ * Convert a StubUint64Compat value into a 'number' if possible.
+ * This value may be negative
+ * @param v
+ */
+export declare const getNumber: (v: StubUint64Compat) => number;
 export declare const isBytes: (v: unknown) => v is StubBytesCompat;
 export declare const isUint64: (v: unknown) => v is StubUint64Compat;
-export declare const isBigUint: (v: unknown) => v is biguint;
 export declare const checkUint64: (v: bigint) => bigint;
 export declare const checkBigUint: (v: bigint) => bigint;
 export declare const checkBytes: (v: Uint8Array) => Uint8Array;
 export declare abstract class AlgoTsPrimitiveCls {
-    private readonly _type;
-    constructor(t: string);
     static [Symbol.hasInstance](x: unknown): x is AlgoTsPrimitiveCls;
-    abstract valueOf(): bigint | string | boolean;
+    abstract valueOf(): bigint | string;
     abstract toBytes(): BytesCls;
 }
 export declare class Uint64Cls extends AlgoTsPrimitiveCls {
-    readonly value: bigint;
+    #private;
     constructor(value: bigint | number | string);
     static [Symbol.hasInstance](x: unknown): x is Uint64Cls;
     static fromCompat(v: StubUint64Compat): Uint64Cls;
-    static getNumber(v: StubUint64Compat): number;
     valueOf(): bigint;
-    toBytes(isDynamic?: boolean): BytesCls;
+    toBytes(): BytesCls;
     asAlgoTs(): uint64;
     asBigInt(): bigint;
     asNumber(): number;
 }
 export declare class BigUintCls extends AlgoTsPrimitiveCls {
-    readonly value: bigint;
+    #private;
     constructor(value: bigint);
     valueOf(): bigint;
     toBytes(): BytesCls;
@@ -49,7 +51,7 @@ export declare class BytesCls extends AlgoTsPrimitiveCls {
     get length(): Uint64Cls;
     toBytes(): BytesCls;
     at(i: StubUint64Compat): BytesCls;
-    slice(start: StubUint64Compat, end: StubUint64Compat): BytesCls;
+    slice(start: undefined | StubUint64Compat, end: undefined | StubUint64Compat): BytesCls;
     concat(other: StubBytesCompat): BytesCls;
     bitwiseAnd(other: StubBytesCompat): BytesCls;
     bitwiseOr(other: StubBytesCompat): BytesCls;
@@ -59,7 +61,7 @@ export declare class BytesCls extends AlgoTsPrimitiveCls {
     private bitwiseOp;
     valueOf(): string;
     static [Symbol.hasInstance](x: unknown): x is BytesCls;
-    static fromCompat(v: StubBytesCompat | undefined): BytesCls;
+    static fromCompat(v: StubBytesCompat | Uint8Array | undefined): BytesCls;
     static fromInterpolation(template: TemplateStringsArray, replacements: StubBytesCompat[]): BytesCls;
     static fromHex(hex: string): BytesCls;
     static fromBase64(b64: string): BytesCls;
@@ -71,7 +73,10 @@ export declare class BytesCls extends AlgoTsPrimitiveCls {
     asUint8Array(): Uint8Array;
 }
 export declare const arrayUtil: {
+    arrayAt(arrayLike: Uint8Array, index: StubUint64Compat): Uint8Array;
     arrayAt<T>(arrayLike: T[], index: StubUint64Compat): T;
-    arraySlice(arrayLike: Uint8Array, start: StubUint64Compat, end: StubUint64Compat): Uint8Array;
-    arraySlice<T>(arrayLike: T[], start: StubUint64Compat, end: StubUint64Compat): T[];
+    arrayAt<T>(arrayLike: T[] | Uint8Array, index: StubUint64Compat): T | Uint8Array;
+    arraySlice(arrayLike: Uint8Array, start: undefined | StubUint64Compat, end: undefined | StubUint64Compat): Uint8Array;
+    arraySlice<T>(arrayLike: T[], start: undefined | StubUint64Compat, end: undefined | StubUint64Compat): T[];
+    arraySlice<T>(arrayLike: Uint8Array | T[], start: undefined | StubUint64Compat, end: undefined | StubUint64Compat): Uint8Array | T[];
 };

package/{index-7MfWJL4Q.js → index-DffKkMrz.js}

@@ -1,5 +1,67 @@
+import { c as ctxMgr } from './execution-context-BznYSiE4.js';
+import { Buffer } from 'node:buffer';
 import { TextDecoder } from 'node:util';
 
+/**
+ * Raised when an `err` op is encountered, or when the testing VM is asked to do something that would cause
+ * the AVM to fail.
+ */
+class AvmError extends Error {
+    constructor(message) {
+        super(message);
+    }
+}
+function avmError(message) {
+    throw new AvmError(message);
+}
+function avmInvariant(condition, message) {
+    if (!condition) {
+        throw new AvmError(message);
+    }
+}
+/**
+ * Raised when an assertion fails
+ */
+class AssertError extends AvmError {
+    constructor(message) {
+        super(message);
+    }
+}
+/**
+ * Raised when testing code errors
+ */
+class InternalError extends Error {
+    constructor(message, options) {
+        super(message, options);
+    }
+}
+function internalError(message) {
+    throw new InternalError(message);
+}
+/**
+ * Raised when unsupported user code is encountered
+ */
+class CodeError extends Error {
+    constructor(message, options) {
+        super(message, options);
+    }
+}
+function codeError(message) {
+    throw new CodeError(message);
+}
+
+var errors = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AssertError: AssertError,
+    AvmError: AvmError,
+    CodeError: CodeError,
+    InternalError: InternalError,
+    avmError: avmError,
+    avmInvariant: avmInvariant,
+    codeError: codeError,
+    internalError: internalError
+});
+
 const BASE32_ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567'.split('');
 const CHAR_TO_NUM = BASE32_ALPHABET.reduce((acc, cur, index) => ((acc[cur] = index), acc), {});
 const base32ToUint8Array = (value) => {
@@ -42,7 +104,7 @@ const uint8ArrayToBase32 = (value) => {
         if (allBytes.length < 1)
             break;
         base32str += BASE32_ALPHABET[a >>> 3];
-        base32str += BASE32_ALPHABET[((a << 2) | ((b || 0) >>> 6)) & 32];
+        base32str += BASE32_ALPHABET[((a << 2) | ((b || 0) >>> 6)) & 31];
         if (allBytes.length < 2)
             break;
         base32str += BASE32_ALPHABET[(b >>> 1) & 31];
@@ -62,60 +124,6 @@ const uint8ArrayToBase32 = (value) => {
     return base32str;
 };
 
-/**
- * Raised when an `err` op is encountered, or when the testing VM is asked to do something that would cause
- * the AVM to fail.
- */
-class AvmError extends Error {
-    constructor(message) {
-        super(message);
-    }
-}
-function avmError(message) {
-    throw new AvmError(message);
-}
-/**
- * Raised when an assertion fails
- */
-class AssertError extends AvmError {
-    constructor(message) {
-        super(message);
-    }
-}
-/**
- * Raised when testing code errors
- */
-class InternalError extends Error {
-    constructor(message, options) {
-        super(message, options);
-    }
-}
-function internalError(message) {
-    throw new InternalError(message);
-}
-/**
- * Raised when unsupported user code is encountered
- */
-class CodeError extends Error {
-    constructor(message, options) {
-        super(message, options);
-    }
-}
-function codeError(message) {
-    throw new CodeError(message);
-}
-
-var errors = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    AssertError: AssertError,
-    AvmError: AvmError,
-    CodeError: CodeError,
-    InternalError: InternalError,
-    avmError: avmError,
-    codeError: codeError,
-    internalError: internalError
-});
-
 const uint8ArrayToBigInt = (v) => {
     // Assume big-endian
     return Array.from(v)
@@ -123,6 +131,16 @@ const uint8ArrayToBigInt = (v) => {
         .map((byte_value, i) => BigInt(byte_value) << BigInt(i * 8))
         .reduce((a, b) => a + b, 0n);
 };
+const hexToUint8Array = (value) => {
+    if (value.length % 2 !== 0) {
+        // TODO: Verify AVM behaviour is to fail
+        throw new AvmError('Hex string must have even number of characters');
+    }
+    return Uint8Array.from(Buffer.from(value, 'hex'));
+};
+const base64ToUint8Array = (value) => {
+    return Uint8Array.from(Buffer.from(value, 'base64'));
+};
 const bigIntToUint8Array = (val, fixedSize = 'dynamic') => {
     if (val === 0n && fixedSize === 'dynamic') {
         return new Uint8Array(0);
@@ -160,7 +178,9 @@ const uint8ArrayToBase64Url = (value) => Buffer.from(value).toString('base64url'
 
 var encodingUtil = /*#__PURE__*/Object.freeze({
     __proto__: null,
+    base64ToUint8Array: base64ToUint8Array,
     bigIntToUint8Array: bigIntToUint8Array,
+    hexToUint8Array: hexToUint8Array,
     uint8ArrayToBase32: uint8ArrayToBase32,
     uint8ArrayToBase64: uint8ArrayToBase64,
     uint8ArrayToBase64Url: uint8ArrayToBase64Url,
@@ -210,6 +230,24 @@ const toBytes = (val) => {
             internalError(`Unsupported arg type ${nameOfType(val)}`);
     }
 };
+/**
+ * Convert a StubUint64Compat value into a 'number' if possible.
+ * This value may be negative
+ * @param v
+ */
+const getNumber = (v) => {
+    if (typeof v == 'boolean')
+        return v ? 1 : 0;
+    if (typeof v == 'number')
+        return v;
+    if (typeof v == 'bigint') {
+        avmInvariant(v <= BigInt(Number.MAX_SAFE_INTEGER) && v >= BigInt(Number.MIN_SAFE_INTEGER), 'value cannot be safely converted to a number');
+        return Number(v);
+    }
+    if (v instanceof Uint64Cls)
+        return v.asNumber();
+    internalError(`Cannot convert ${v} to number`);
+};
 const isBytes = (v) => {
     if (typeof v === 'string')
         return true;
@@ -226,19 +264,16 @@ const isUint64 = (v) => {
         return true;
     return v instanceof Uint64Cls;
 };
-const isBigUint = (v) => {
-    return v instanceof BigUintCls;
-};
 const checkUint64 = (v) => {
     const u64 = BigInt.asUintN(64, v);
     if (u64 !== v)
-        throw new AvmError(`Uint64 over or underflow`);
+        throw new AvmError(`Uint64 overflow or underflow`);
     return u64;
 };
 const checkBigUint = (v) => {
     const uBig = BigInt.asUintN(64 * 8, v);
     if (uBig !== v)
-        throw new AvmError(`BigUint over or underflow`);
+        throw new AvmError(`BigUint overflow or underflow`);
     return uBig;
 };
 const checkBytes = (v) => {
@@ -246,24 +281,44 @@ const checkBytes = (v) => {
         throw new AvmError(`Bytes length ${v.length} exceeds maximum length ${MAX_BYTES_SIZE}`);
     return v;
 };
-class AlgoTsPrimitiveCls {
-    _type = AlgoTsPrimitiveCls.name;
-    constructor(t) {
-        this._type = `${AlgoTsPrimitiveCls.name}.${t}`;
+/**
+ * Verifies that an object is an instance of a type based on its name rather than reference equality.
+ *
+ * This is useful in scenarios where a module loader has loaded a module twice and hence two instances of a
+ * type do not have reference equality on their constructors.
+ * @param subject The object to check
+ * @param typeCtor The ctor of the type
+ */
+function isInstanceOfTypeByName(subject, typeCtor) {
+    if (subject === null || typeof subject !== 'object')
+        return false;
+    let ctor = subject.constructor;
+    while (typeof ctor === 'function') {
+        if (ctor.name === typeCtor.name)
+            return true;
+        ctor = Object.getPrototypeOf(ctor);
     }
+    return false;
+}
+class AlgoTsPrimitiveCls {
     static [Symbol.hasInstance](x) {
-        return x instanceof Object && '_type' in x && x['_type'].startsWith(AlgoTsPrimitiveCls.name);
+        return isInstanceOfTypeByName(x, AlgoTsPrimitiveCls);
     }
 }
 class Uint64Cls extends AlgoTsPrimitiveCls {
-    value;
+    #value;
     constructor(value) {
-        super(Uint64Cls.name);
-        this.value = BigInt(value);
-        checkUint64(this.value);
+        super();
+        this.#value = BigInt(value);
+        checkUint64(this.#value);
+        Object.defineProperty(this, 'uint64', {
+            value: this.#value.toString(),
+            writable: false,
+            enumerable: true,
+        });
     }
     static [Symbol.hasInstance](x) {
-        return x instanceof Object && '_type' in x && x['_type'].endsWith(Uint64Cls.name);
+        return isInstanceOfTypeByName(x, Uint64Cls);
     }
     static fromCompat(v) {
         if (typeof v == 'boolean')
@@ -276,54 +331,56 @@ class Uint64Cls extends AlgoTsPrimitiveCls {
             return v;
         internalError(`Cannot convert ${v} to uint64`);
     }
-    static getNumber(v) {
-        return Uint64Cls.fromCompat(v).asNumber();
-    }
     valueOf() {
-        return this.value;
+        return this.#value;
     }
-    toBytes(isDynamic = false) {
-        return new BytesCls(bigIntToUint8Array(this.value, isDynamic ? 'dynamic' : 8));
+    toBytes() {
+        return new BytesCls(bigIntToUint8Array(this.#value, 8));
     }
     asAlgoTs() {
         return this;
     }
     asBigInt() {
-        return this.value;
+        return this.#value;
     }
     asNumber() {
-        if (this.value > Number.MAX_SAFE_INTEGER) {
+        if (this.#value > Number.MAX_SAFE_INTEGER) {
             throw new AvmError('value cannot be safely converted to a number');
         }
-        return Number(this.value);
+        return Number(this.#value);
     }
 }
 class BigUintCls extends AlgoTsPrimitiveCls {
-    value;
+    #value;
     constructor(value) {
-        super(BigUintCls.name);
-        this.value = value;
+        super();
+        this.#value = value;
+        Object.defineProperty(this, 'biguint', {
+            value: value.toString(),
+            writable: false,
+            enumerable: true,
+        });
     }
     valueOf() {
-        return this.value;
+        return this.#value;
     }
     toBytes() {
-        return new BytesCls(bigIntToUint8Array(this.value));
+        return new BytesCls(bigIntToUint8Array(this.#value));
     }
     asAlgoTs() {
         return this;
     }
     asBigInt() {
-        return this.value;
+        return this.#value;
     }
     asNumber() {
-        if (this.value > Number.MAX_SAFE_INTEGER) {
+        if (this.#value > Number.MAX_SAFE_INTEGER) {
             throw new AvmError('value cannot be safely converted to a number');
         }
-        return Number(this.value);
+        return Number(this.#value);
     }
     static [Symbol.hasInstance](x) {
-        return x instanceof Object && '_type' in x && x['_type'].endsWith(BigUintCls.name);
+        return isInstanceOfTypeByName(x, BigUintCls);
     }
     static fromCompat(v) {
         if (typeof v == 'boolean')
@@ -333,7 +390,7 @@ class BigUintCls extends AlgoTsPrimitiveCls {
         if (typeof v == 'bigint')
             return new BigUintCls(v);
         if (v instanceof Uint64Cls)
-            return new BigUintCls(v.value);
+            return new BigUintCls(v.valueOf());
         if (v instanceof BytesCls)
             return v.toBigUint();
         if (v instanceof BigUintCls)
@@ -344,9 +401,15 @@ class BigUintCls extends AlgoTsPrimitiveCls {
 class BytesCls extends AlgoTsPrimitiveCls {
     #v;
     constructor(v) {
-        super(BytesCls.name);
+        super();
         this.#v = v;
         checkBytes(this.#v);
+        // Add an enumerable property for debugging code to show
+        Object.defineProperty(this, 'bytes', {
+            value: uint8ArrayToHex(this.#v),
+            writable: false,
+            enumerable: true,
+        });
     }
     get length() {
         return new Uint64Cls(this.#v.length);
@@ -355,13 +418,10 @@ class BytesCls extends AlgoTsPrimitiveCls {
         return this;
     }
     at(i) {
-        const start = Uint64Cls.fromCompat(i).asNumber();
-        return new BytesCls(this.#v.slice(start, start + 1));
+        return new BytesCls(arrayUtil.arrayAt(this.#v, i));
     }
     slice(start, end) {
-        const startNumber = start instanceof Uint64Cls ? start.asNumber() : start;
-        const endNumber = end instanceof Uint64Cls ? end.asNumber() : end;
-        const sliced = arrayUtil.arraySlice(this.#v, startNumber, endNumber);
+        const sliced = arrayUtil.arraySlice(this.#v, start, end);
         return new BytesCls(sliced);
     }
     concat(other) {
@@ -408,10 +468,10 @@ class BytesCls extends AlgoTsPrimitiveCls {
         return new BytesCls(result);
     }
     valueOf() {
-        return uint8ArrayToUtf8(this.#v);
+        return uint8ArrayToHex(this.#v);
     }
     static [Symbol.hasInstance](x) {
-        return x instanceof Object && '_type' in x && x['_type'].endsWith(BytesCls.name);
+        return isInstanceOfTypeByName(x, BytesCls);
     }
     static fromCompat(v) {
         if (v === undefined)
@@ -436,10 +496,10 @@ class BytesCls extends AlgoTsPrimitiveCls {
             .reduce((a, b) => a.concat(b));
     }
     static fromHex(hex) {
-        return new BytesCls(Uint8Array.from(Buffer.from(hex, 'hex')));
+        return new BytesCls(hexToUint8Array(hex));
     }
     static fromBase64(b64) {
-        return new BytesCls(Uint8Array.from(Buffer.from(b64, 'base64')));
+        return new BytesCls(base64ToUint8Array(b64));
     }
     static fromBase32(b32) {
         return new BytesCls(base32ToUint8Array(b32));
@@ -451,7 +511,7 @@ class BytesCls extends AlgoTsPrimitiveCls {
         return new BigUintCls(uint8ArrayToBigInt(this.#v));
     }
     toString() {
-        return this.valueOf();
+        return uint8ArrayToUtf8(this.#v);
     }
     asAlgoTs() {
         return this;
@@ -460,12 +520,25 @@ class BytesCls extends AlgoTsPrimitiveCls {
         return this.#v;
     }
 }
-const arrayUtil = new (class {
+const arrayUtil = new (class ArrayUtil {
     arrayAt(arrayLike, index) {
-        return arrayLike.at(Uint64Cls.fromCompat(index).asNumber()) ?? avmError('Index out of bounds');
+        const indexNum = getNumber(index);
+        if (arrayLike instanceof Uint8Array) {
+            const res = arrayLike.slice(indexNum, indexNum === -1 ? undefined : indexNum + 1);
+            avmInvariant(res.length, 'Index out of bounds');
+            return res;
+        }
+        return arrayLike.at(indexNum) ?? avmError('Index out of bounds');
     }
     arraySlice(arrayLike, start, end) {
-        return arrayLike.slice(Uint64Cls.getNumber(start), Uint64Cls.getNumber(end));
+        const startNum = start === undefined ? undefined : getNumber(start);
+        const endNum = end === undefined ? undefined : getNumber(end);
+        if (arrayLike instanceof Uint8Array) {
+            return arrayLike.slice(startNum, endNum);
+        }
+        else {
+            return arrayLike.slice(startNum, endNum);
+        }
     }
 })();
 
@@ -479,7 +552,7 @@ var primitives = /*#__PURE__*/Object.freeze({
     checkBigUint: checkBigUint,
     checkBytes: checkBytes,
     checkUint64: checkUint64,
-    isBigUint: isBigUint,
+    getNumber: getNumber,
     isBytes: isBytes,
     isUint64: isUint64,
     toBytes: toBytes,
@@ -490,12 +563,30 @@ function Uint64(v) {
     return Uint64Cls.fromCompat(v).asAlgoTs();
 }
 function BigUint(v) {
+    if (typeof v === 'string')
+        v = BigInt(v);
+    else if (v === undefined)
+        v = 0n;
     return BigUintCls.fromCompat(v).asAlgoTs();
 }
 function Bytes(value, ...replacements) {
     if (isTemplateStringsArray(value)) {
         return BytesCls.fromInterpolation(value, replacements).asAlgoTs();
     }
+    else if (typeof value === 'bigint' || value instanceof BigUintCls) {
+        return BigUintCls.fromCompat(value).toBytes().asAlgoTs();
+    }
+    else if (typeof value === 'number' || value instanceof Uint64Cls) {
+        return Uint64Cls.fromCompat(value).toBytes().asAlgoTs();
+    }
+    else if (typeof value === 'object' && Symbol.iterator in value) {
+        const valueItems = Array.from(value).map((v) => getNumber(v));
+        const invalidValue = valueItems.find((v) => v < 0 && v > 255);
+        if (invalidValue) {
+            throw new CodeError(`Cannot convert ${invalidValue} to a byte`);
+        }
+        return new BytesCls(new Uint8Array(value)).asAlgoTs();
+    }
     else {
         return BytesCls.fromCompat(value).asAlgoTs();
     }
@@ -525,24 +616,6 @@ function isTemplateStringsArray(v) {
     return Boolean(v) && Array.isArray(v) && typeof v[0] === 'string';
 }
 
-const ctxMgr = {
-    set instance(ctx) {
-        const instance = global.puyaTsExecutionContext;
-        if (instance != undefined)
-            throw new Error('Execution context has already been set');
-        global.puyaTsExecutionContext = ctx;
-    },
-    get instance() {
-        const instance = global.puyaTsExecutionContext;
-        if (instance == undefined)
-            throw new Error('No execution context has been set');
-        return instance;
-    },
-    reset() {
-        global.puyaTsExecutionContext = undefined;
-    },
-};
-
 function log(...args) {
     ctxMgr.instance.log(args.map(toBytes).reduce((left, right) => left.concat(right)));
 }
@@ -737,5 +810,5 @@ var index = /*#__PURE__*/Object.freeze({
     baremethod: baremethod
 });
 
-export { AssertError as A, BytesCls as B, Contract as C, DynamicArray as D, OpUpFeeSource as O, Str as S, Tuple as T, Uint64 as U, errors as a, err as b, ctxMgr as c, assert as d, encodingUtil as e, assertMatch as f, ensureBudget as g, abimethod as h, index as i, BaseContract as j, BigUint as k, log as l, match as m, Bytes as n, OnCompleteAction as o, primitives as p, baremethod as q, UintN as r, UFixedNxM as s, Byte as t, urange as u, Bool as v, StaticArray as w, Address as x };
-//# sourceMappingURL=index-7MfWJL4Q.js.map
+export { AssertError as A, BytesCls as B, Contract as C, DynamicArray as D, OpUpFeeSource as O, Str as S, Tuple as T, Uint64 as U, errors as a, err as b, assert as c, assertMatch as d, encodingUtil as e, ensureBudget as f, abimethod as g, BaseContract as h, index as i, BigUint as j, Bytes as k, log as l, match as m, OnCompleteAction as n, baremethod as o, primitives as p, UintN as q, UFixedNxM as r, Byte as s, Bool as t, urange as u, StaticArray as v, Address as w };
+//# sourceMappingURL=index-DffKkMrz.js.map