@algorandfoundation/algorand-typescript-testing 1.0.0-beta.14 → 1.0.0-beta.16

package/abi-metadata-CRbKDwP2.js

@@ -0,0 +1,90 @@
+import js_sha512 from 'js-sha512';
+import { al as getArc4TypeName$1 } from './crypto-DmkHXzw6.js';
+
+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;
+};
+
+export { getContractMethodAbiMetadata as a, getContractAbiMetadata as b, copyAbiMetadatas as c, attachAbiMetadata as d, captureMethodConfig as e, getArc4Selector as g, isContractProxy as i };
+//# sourceMappingURL=abi-metadata-CRbKDwP2.js.map

package/abi-metadata-CRbKDwP2.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"abi-metadata-CRbKDwP2.js","sources":["../src/abi-metadata.ts"],"sourcesContent":["import type { BaseContract, Contract } from '@algorandfoundation/algorand-typescript'\nimport type { AbiMethodConfig, BareMethodConfig, CreateOptions, OnCompleteActionStr } from '@algorandfoundation/algorand-typescript/arc4'\nimport js_sha512 from 'js-sha512'\nimport type { TypeInfo } from './encoders'\nimport { getArc4TypeName as getArc4TypeNameForARC4Encoded } from './impl/encoded-types'\nimport type { DeliberateAny } from './typescript-helpers'\n\nexport interface AbiMetadata {\n  methodName: string\n  methodSignature: string | undefined\n  argTypes: string[]\n  returnType: string\n  onCreate?: CreateOptions\n  allowActions?: OnCompleteActionStr[]\n}\nconst AbiMetaSymbol = Symbol('AbiMetadata')\nexport const isContractProxy = Symbol('isContractProxy')\nexport const attachAbiMetadata = (contract: { new (): Contract }, methodName: string, metadata: AbiMetadata): void => {\n  const metadatas: Record<string, AbiMetadata> = (AbiMetaSymbol in contract ? contract[AbiMetaSymbol] : {}) as Record<string, AbiMetadata>\n  metadatas[methodName] = metadata\n  if (!(AbiMetaSymbol in contract)) {\n    Object.defineProperty(contract, AbiMetaSymbol, {\n      value: metadatas,\n      writable: true,\n      enumerable: false,\n    })\n  }\n}\n\nexport const copyAbiMetadatas = <T extends BaseContract>(sourceContract: T, targetContract: T): void => {\n  const metadatas = getContractAbiMetadata(sourceContract)\n  Object.defineProperty(targetContract, AbiMetaSymbol, {\n    value: metadatas,\n    writable: true,\n    enumerable: false,\n  })\n}\n\nexport const captureMethodConfig = <T extends Contract>(\n  contract: T,\n  methodName: string,\n  config?: AbiMethodConfig<T> | BareMethodConfig,\n): void => {\n  const metadata = getContractMethodAbiMetadata(contract, methodName)\n  metadata.onCreate = config?.onCreate ?? 'disallow'\n  metadata.allowActions = ([] as OnCompleteActionStr[]).concat(config?.allowActions ?? 'NoOp')\n}\n\nexport const hasAbiMetadata = <T extends Contract>(contract: T): boolean => {\n  const contractClass = contract.constructor as { new (): T }\n  return (\n    Object.getOwnPropertySymbols(contractClass).some((s) => s.toString() === AbiMetaSymbol.toString()) || AbiMetaSymbol in contractClass\n  )\n}\nexport const getContractAbiMetadata = <T extends BaseContract>(contract: T): Record<string, AbiMetadata> => {\n  if ((contract as DeliberateAny)[isContractProxy]) {\n    return (contract as DeliberateAny)[AbiMetaSymbol] as Record<string, AbiMetadata>\n  }\n  const contractClass = contract.constructor as { new (): T }\n  const s = Object.getOwnPropertySymbols(contractClass).find((s) => s.toString() === AbiMetaSymbol.toString())\n  const metadatas: Record<string, AbiMetadata> = (\n    s ? (contractClass as DeliberateAny)[s] : AbiMetaSymbol in contractClass ? contractClass[AbiMetaSymbol] : {}\n  ) as Record<string, AbiMetadata>\n  return metadatas\n}\n\nexport const getContractMethodAbiMetadata = <T extends BaseContract>(contract: T, methodName: string): AbiMetadata => {\n  const metadatas = getContractAbiMetadata(contract)\n  return metadatas[methodName]\n}\n\nexport const getArc4Signature = (metadata: AbiMetadata): string => {\n  if (metadata.methodSignature === undefined) {\n    const argTypes = metadata.argTypes.map((t) => JSON.parse(t) as TypeInfo).map(getArc4TypeName)\n    const returnType = getArc4TypeName(JSON.parse(metadata.returnType) as TypeInfo)\n    metadata.methodSignature = `${metadata.methodName}(${argTypes.join(',')})${returnType}`\n  }\n  return metadata.methodSignature\n}\n\nexport const getArc4Selector = (metadata: AbiMetadata): Uint8Array => {\n  const hash = js_sha512.sha512_256.array(getArc4Signature(metadata))\n  return new Uint8Array(hash.slice(0, 4))\n}\n\nconst getArc4TypeName = (t: TypeInfo): string => {\n  const map: Record<string, string | ((t: TypeInfo) => string)> = {\n    void: 'void',\n    account: 'account',\n    application: 'application',\n    asset: 'asset',\n    boolean: 'bool',\n    biguint: 'uint512',\n    bytes: 'byte[]',\n    string: 'string',\n    uint64: 'uint64',\n    OnCompleteAction: 'uint64',\n    TransactionType: 'uint64',\n    Transaction: 'txn',\n    PaymentTxn: 'pay',\n    KeyRegistrationTxn: 'keyreg',\n    AssetConfigTxn: 'acfg',\n    AssetTransferTxn: 'axfer',\n    AssetFreezeTxn: 'afrz',\n    ApplicationTxn: 'appl',\n    'Tuple(<.*>)?': (t) =>\n      `(${Object.values(t.genericArgs as Record<string, TypeInfo>)\n        .map(getArc4TypeName)\n        .join(',')})`,\n  }\n  const entry = Object.entries(map).find(([k, _]) => new RegExp(`^${k}$`, 'i').test(t.name))?.[1]\n  if (entry === undefined) {\n    return getArc4TypeNameForARC4Encoded(t) ?? t.name\n  }\n  if (entry instanceof Function) {\n    return entry(t)\n  }\n  return entry\n}\n"],"names":["getArc4TypeNameForARC4Encoded"],"mappings":";;;AAeA,MAAM,aAAa,GAAG,MAAM,CAAC,aAAa,CAAC;MAC9B,eAAe,GAAG,MAAM,CAAC,iBAAiB;AAC1C,MAAA,iBAAiB,GAAG,CAAC,QAA8B,EAAE,UAAkB,EAAE,QAAqB,KAAU;AACnH,IAAA,MAAM,SAAS,IAAiC,aAAa,IAAI,QAAQ,GAAG,QAAQ,CAAC,aAAa,CAAC,GAAG,EAAE,CAAgC;AACxI,IAAA,SAAS,CAAC,UAAU,CAAC,GAAG,QAAQ;AAChC,IAAA,IAAI,EAAE,aAAa,IAAI,QAAQ,CAAC,EAAE;AAChC,QAAA,MAAM,CAAC,cAAc,CAAC,QAAQ,EAAE,aAAa,EAAE;AAC7C,YAAA,KAAK,EAAE,SAAS;AAChB,YAAA,QAAQ,EAAE,IAAI;AACd,YAAA,UAAU,EAAE,KAAK;AAClB,SAAA,CAAC;;AAEN;MAEa,gBAAgB,GAAG,CAAyB,cAAiB,EAAE,cAAiB,KAAU;AACrG,IAAA,MAAM,SAAS,GAAG,sBAAsB,CAAC,cAAc,CAAC;AACxD,IAAA,MAAM,CAAC,cAAc,CAAC,cAAc,EAAE,aAAa,EAAE;AACnD,QAAA,KAAK,EAAE,SAAS;AAChB,QAAA,QAAQ,EAAE,IAAI;AACd,QAAA,UAAU,EAAE,KAAK;AAClB,KAAA,CAAC;AACJ;AAEa,MAAA,mBAAmB,GAAG,CACjC,QAAW,EACX,UAAkB,EAClB,MAA8C,KACtC;IACR,MAAM,QAAQ,GAAG,4BAA4B,CAAC,QAAQ,EAAE,UAAU,CAAC;IACnE,QAAQ,CAAC,QAAQ,GAAG,MAAM,EAAE,QAAQ,IAAI,UAAU;AAClD,IAAA,QAAQ,CAAC,YAAY,GAAI,EAA4B,CAAC,MAAM,CAAC,MAAM,EAAE,YAAY,IAAI,MAAM,CAAC;AAC9F;AAQa,MAAA,sBAAsB,GAAG,CAAyB,QAAW,KAAiC;AACzG,IAAA,IAAK,QAA0B,CAAC,eAAe,CAAC,EAAE;AAChD,QAAA,OAAQ,QAA0B,CAAC,aAAa,CAAgC;;AAElF,IAAA,MAAM,aAAa,GAAG,QAAQ,CAAC,WAA4B;IAC3D,MAAM,CAAC,GAAG,MAAM,CAAC,qBAAqB,CAAC,aAAa,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,QAAQ,EAAE,KAAK,aAAa,CAAC,QAAQ,EAAE,CAAC;AAC5G,IAAA,MAAM,SAAS,IACb,CAAC,GAAI,aAA+B,CAAC,CAAC,CAAC,GAAG,aAAa,IAAI,aAAa,GAAG,aAAa,CAAC,aAAa,CAAC,GAAG,EAAE,CAC9E;AAChC,IAAA,OAAO,SAAS;AAClB;MAEa,4BAA4B,GAAG,CAAyB,QAAW,EAAE,UAAkB,KAAiB;AACnH,IAAA,MAAM,SAAS,GAAG,sBAAsB,CAAC,QAAQ,CAAC;AAClD,IAAA,OAAO,SAAS,CAAC,UAAU,CAAC;AAC9B;AAEO,MAAM,gBAAgB,GAAG,CAAC,QAAqB,KAAY;AAChE,IAAA,IAAI,QAAQ,CAAC,eAAe,KAAK,SAAS,EAAE;QAC1C,MAAM,QAAQ,GAAG,QAAQ,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,KAAK,CAAC,CAAC,CAAa,CAAC,CAAC,GAAG,CAAC,eAAe,CAAC;AAC7F,QAAA,MAAM,UAAU,GAAG,eAAe,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,UAAU,CAAa,CAAC;AAC/E,QAAA,QAAQ,CAAC,eAAe,GAAG,CAAG,EAAA,QAAQ,CAAC,UAAU,CAAA,CAAA,EAAI,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,CAAI,CAAA,EAAA,UAAU,EAAE;;IAEzF,OAAO,QAAQ,CAAC,eAAe;AACjC,CAAC;AAEY,MAAA,eAAe,GAAG,CAAC,QAAqB,KAAgB;AACnE,IAAA,MAAM,IAAI,GAAG,SAAS,CAAC,UAAU,CAAC,KAAK,CAAC,gBAAgB,CAAC,QAAQ,CAAC,CAAC;AACnE,IAAA,OAAO,IAAI,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AACzC;AAEA,MAAM,eAAe,GAAG,CAAC,CAAW,KAAY;AAC9C,IAAA,MAAM,GAAG,GAAuD;AAC9D,QAAA,IAAI,EAAE,MAAM;AACZ,QAAA,OAAO,EAAE,SAAS;AAClB,QAAA,WAAW,EAAE,aAAa;AAC1B,QAAA,KAAK,EAAE,OAAO;AACd,QAAA,OAAO,EAAE,MAAM;AACf,QAAA,OAAO,EAAE,SAAS;AAClB,QAAA,KAAK,EAAE,QAAQ;AACf,QAAA,MAAM,EAAE,QAAQ;AAChB,QAAA,MAAM,EAAE,QAAQ;AAChB,QAAA,gBAAgB,EAAE,QAAQ;AAC1B,QAAA,eAAe,EAAE,QAAQ;AACzB,QAAA,WAAW,EAAE,KAAK;AAClB,QAAA,UAAU,EAAE,KAAK;AACjB,QAAA,kBAAkB,EAAE,QAAQ;AAC5B,QAAA,cAAc,EAAE,MAAM;AACtB,QAAA,gBAAgB,EAAE,OAAO;AACzB,QAAA,cAAc,EAAE,MAAM;AACtB,QAAA,cAAc,EAAE,MAAM;AACtB,QAAA,cAAc,EAAE,CAAC,CAAC,KAChB,CAAA,CAAA,EAAI,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,WAAuC;aACxD,GAAG,CAAC,eAAe;aACnB,IAAI,CAAC,GAAG,CAAC,CAAG,CAAA,CAAA;KAClB;AACD,IAAA,MAAM,KAAK,GAAG,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,IAAI,MAAM,CAAC,CAAI,CAAA,EAAA,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC;AAC/F,IAAA,IAAI,KAAK,KAAK,SAAS,EAAE;QACvB,OAAOA,iBAA6B,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI;;AAEnD,IAAA,IAAI,KAAK,YAAY,QAAQ,EAAE;AAC7B,QAAA,OAAO,KAAK,CAAC,CAAC,CAAC;;AAEjB,IAAA,OAAO,KAAK;AACd,CAAC;;;;"}

package/{asset-params-CzUcFBcQ.js → asset-params-BfwgiVLK.js}

@@ -1,12 +1,13 @@
-import { internal, BigUint, Uint64, Bytes, Base64 } from '@algorandfoundation/algorand-typescript';
 import { ARC4Encoded } from '@algorandfoundation/algorand-typescript/arc4';
-import { h as asMaybeUint64Cls, o as asMaybeBytesCls, O as asMaybeBigUintCls, L as BytesBackedCls, N as Uint64BackedCls, j as asUint64Cls, a2 as encodeArc4Impl, _ as nameOfType, ad as getArc4Encoder, A as AccountCls, a as ApplicationCls, b as AssetCls, ac as arc4Encoders, R as asUint8Array, K as asBytes, l as lazyContext, u as getRandomBytes, f as asUint64, d as Account, aq as getObjectReference, an as sha256, ar as getApplicationAddress, as as MIN_TXN_FEE, at as DEFAULT_ACCOUNT_MIN_BALANCE, au as DEFAULT_MAX_TXN_LIFE, Z as ZERO_ADDRESS, av as DEFAULT_ASSET_CREATE_MIN_BALANCE, aw as DEFAULT_ASSET_OPT_IN_MIN_BALANCE, ax as DEFAULT_GLOBAL_GENESIS_HASH, ay as asBigUint, I as BITS_IN_BYTE, s as MAX_BYTES_SIZE, V as asBytesCls, t as testInvariant, z as MAX_UINT8, az as binaryStringToBytes, aA as UINT64_SIZE, aB as notImplementedError, M as MAX_UINT64 } from './encoded-types-9PSWSstF.js';
+import { encodingUtil } from '@algorandfoundation/puya-ts';
+import { q as asMaybeUint64Cls, y as asMaybeBytesCls, a8 as asMaybeBigUintCls, a5 as BytesBackedCls, a6 as Uint64BackedCls, r as asUint64Cls, aq as encodeArc4Impl, I as InternalError, aj as nameOfType, aB as getArc4Encoder, A as AccountCls, f as ApplicationCls, g as AssetCls, aA as arc4Encoders, z as asUint8Array, K as BigUint, x as asBytes, G as Uint64, l as lazyContext, O as getRandomBytes, o as asUint64, N as Account, aN as getObjectReference, h as Bytes, aK as sha256, aO as getApplicationAddress, aP as MIN_TXN_FEE, aQ as DEFAULT_ACCOUNT_MIN_BALANCE, aR as DEFAULT_MAX_TXN_LIFE, aS as ZERO_ADDRESS, aT as DEFAULT_ASSET_CREATE_MIN_BALANCE, aU as DEFAULT_ASSET_OPT_IN_MIN_BALANCE, aV as DEFAULT_GLOBAL_GENESIS_HASH, U as Uint64Cls, a as BytesCls, a2 as AvmError, B as BigUintCls, an as checkBigUint, aW as asBigUint, _ as BITS_IN_BYTE, L as MAX_BYTES_SIZE, C as CodeError, aX as isUint64, ad as asBytesCls, F as testInvariant, S as MAX_UINT8, aY as binaryStringToBytes, aZ as UINT64_SIZE, a3 as NotImplementedError, M as MAX_UINT64 } from './crypto-DmkHXzw6.js';
+import { Base64 } from '@algorandfoundation/algorand-typescript';
 
 const booleanFromBytes = (val) => {
-    return internal.encodingUtil.uint8ArrayToBigInt(asUint8Array(val)) > 0n;
+    return encodingUtil.uint8ArrayToBigInt(asUint8Array(val)) > 0n;
 };
 const bigUintFromBytes = (val) => {
-    return BigUint(internal.encodingUtil.uint8ArrayToBigInt(asUint8Array(val)));
+    return BigUint(encodingUtil.uint8ArrayToBigInt(asUint8Array(val)));
 };
 const bytesFromBytes = (val) => {
     return asBytes(val);
@@ -15,13 +16,13 @@ const stringFromBytes = (val) => {
     return asBytes(val).toString();
 };
 const uint64FromBytes = (val) => {
-    return Uint64(internal.encodingUtil.uint8ArrayToBigInt(asUint8Array(val)));
+    return Uint64(encodingUtil.uint8ArrayToBigInt(asUint8Array(val)));
 };
 const onCompletionFromBytes = (val) => {
-    return Uint64(internal.encodingUtil.uint8ArrayToBigInt(asUint8Array(val)));
+    return Uint64(encodingUtil.uint8ArrayToBigInt(asUint8Array(val)));
 };
 const transactionTypeFromBytes = (val) => {
-    return Uint64(internal.encodingUtil.uint8ArrayToBigInt(asUint8Array(val)));
+    return Uint64(encodingUtil.uint8ArrayToBigInt(asUint8Array(val)));
 };
 const encoders = {
     account: AccountCls.fromBytes,
@@ -64,7 +65,7 @@ const toBytes = (val) => {
     if (Array.isArray(val) || typeof val === 'object') {
         return encodeArc4Impl('', val);
     }
-    internal.errors.internalError(`Invalid type for bytes: ${nameOfType(val)}`);
+    throw new InternalError(`Invalid type for bytes: ${nameOfType(val)}`);
 };
 
 class BlockData {
@@ -200,7 +201,7 @@ const Global = {
         const data = getGlobalData();
         if (data.logicSigVersion !== undefined)
             return data.logicSigVersion;
-        throw new internal.errors.InternalError(getMissingValueErrorMessage('logicSigVersion'));
+        throw new InternalError(getMissingValueErrorMessage('logicSigVersion'));
     },
     /**
      * Current round number. ApplicationType mode only.
@@ -247,7 +248,7 @@ const Global = {
         if (data.groupId !== undefined)
             return data.groupId;
         const reference = getObjectReference(lazyContext.activeGroup);
-        const referenceBytes = Bytes(internal.encodingUtil.bigIntToUint8Array(reference));
+        const referenceBytes = Bytes(encodingUtil.bigIntToUint8Array(reference));
         return sha256(referenceBytes);
     },
     /**
@@ -257,7 +258,7 @@ const Global = {
         const data = getGlobalData();
         if (data.opcodeBudget !== undefined)
             return data.opcodeBudget;
-        throw new internal.errors.InternalError(getMissingValueErrorMessage('opcodeBudget'));
+        throw new InternalError(getMissingValueErrorMessage('opcodeBudget'));
     },
     /**
      * The application ID of the application that called this application. 0 if this application is at the top-level. ApplicationType mode only.
@@ -499,18 +500,18 @@ const VoterParams = {
 };
 
 const addw = (a, b) => {
-    const uint64A = internal.primitives.Uint64Cls.fromCompat(a);
-    const uint64B = internal.primitives.Uint64Cls.fromCompat(b);
+    const uint64A = Uint64Cls.fromCompat(a);
+    const uint64B = Uint64Cls.fromCompat(b);
     const sum = uint64A.asBigInt() + uint64B.asBigInt();
     return toUint128(sum);
 };
 const base64Decode = (e, a) => {
     const encoding = e === Base64.StdEncoding ? 'base64' : 'base64url';
-    const bytesValue = internal.primitives.BytesCls.fromCompat(a);
+    const bytesValue = BytesCls.fromCompat(a);
     const stringValue = bytesValue.toString();
     const bufferResult = Buffer.from(stringValue, encoding);
     if (bufferResult.toString(encoding) !== stringValue) {
-        internal.errors.avmError('illegal base64 data');
+        throw new AvmError('illegal base64 data');
     }
     const uint8ArrayResult = new Uint8Array(bufferResult);
     return Bytes(uint8ArrayResult);
@@ -523,28 +524,28 @@ const bitLength = (a) => {
     return Uint64(binaryValue.length);
 };
 const bsqrt = (a) => {
-    const bigUintClsValue = internal.primitives.BigUintCls.fromCompat(a);
-    const bigintValue = internal.primitives.checkBigUint(bigUintClsValue.asBigInt());
+    const bigUintClsValue = BigUintCls.fromCompat(a);
+    const bigintValue = checkBigUint(bigUintClsValue.asBigInt());
     const sqrtValue = squareroot(bigintValue);
     return asBigUint(sqrtValue);
 };
 const btoi = (a) => {
-    const bytesValue = internal.primitives.BytesCls.fromCompat(a);
+    const bytesValue = BytesCls.fromCompat(a);
     if (bytesValue.length.asAlgoTs() > BITS_IN_BYTE) {
-        internal.errors.avmError(`btoi arg too long, got [${bytesValue.length.valueOf()}]bytes`);
+        throw new AvmError(`btoi arg too long, got [${bytesValue.length.valueOf()}]bytes`);
     }
     return bytesValue.toUint64().asAlgoTs();
 };
 const bzero = (a) => {
-    const size = internal.primitives.Uint64Cls.fromCompat(a).asBigInt();
+    const size = Uint64Cls.fromCompat(a).asBigInt();
     if (size > MAX_BYTES_SIZE) {
-        internal.errors.avmError('bzero attempted to create a too large string');
+        throw new AvmError('bzero attempted to create a too large string');
     }
     return Bytes(new Uint8Array(Number(size)));
 };
 const concat = (a, b) => {
-    const bytesA = internal.primitives.BytesCls.fromCompat(a);
-    const bytesB = internal.primitives.BytesCls.fromCompat(b);
+    const bytesA = BytesCls.fromCompat(a);
+    const bytesB = BytesCls.fromCompat(b);
     return bytesA.concat(bytesB).asAlgoTs();
 };
 const divmodw = (a, b, c, d) => {
@@ -556,68 +557,68 @@ const divmodw = (a, b, c, d) => {
 };
 const divw = (a, b, c) => {
     const i = uint128ToBigInt(a, b);
-    const j = internal.primitives.Uint64Cls.fromCompat(c).asBigInt();
+    const j = Uint64Cls.fromCompat(c).asBigInt();
     return Uint64(i / j);
 };
 const exp = (a, b) => {
-    const base = internal.primitives.Uint64Cls.fromCompat(a).asBigInt();
-    const exponent = internal.primitives.Uint64Cls.fromCompat(b).asBigInt();
+    const base = Uint64Cls.fromCompat(a).asBigInt();
+    const exponent = Uint64Cls.fromCompat(b).asBigInt();
     if (base === 0n && exponent === 0n) {
-        throw internal.errors.codeError('0 ** 0 is undefined');
+        throw new CodeError('0 ** 0 is undefined');
     }
     return Uint64(base ** exponent);
 };
 const expw = (a, b) => {
-    const base = internal.primitives.Uint64Cls.fromCompat(a).asBigInt();
-    const exponent = internal.primitives.Uint64Cls.fromCompat(b).asBigInt();
+    const base = Uint64Cls.fromCompat(a).asBigInt();
+    const exponent = Uint64Cls.fromCompat(b).asBigInt();
     if (base === 0n && exponent === 0n) {
-        throw internal.errors.codeError('0 ** 0 is undefined');
+        throw new CodeError('0 ** 0 is undefined');
     }
     return toUint128(base ** exponent);
 };
 const extract = ((a, b, c) => {
-    const bytesValue = internal.primitives.BytesCls.fromCompat(a);
+    const bytesValue = BytesCls.fromCompat(a);
     const bytesLength = bytesValue.length.asBigInt();
-    const start = internal.primitives.Uint64Cls.fromCompat(b).asBigInt();
-    const length = c !== undefined ? internal.primitives.Uint64Cls.fromCompat(c).asBigInt() : undefined;
+    const start = Uint64Cls.fromCompat(b).asBigInt();
+    const length = c !== undefined ? Uint64Cls.fromCompat(c).asBigInt() : undefined;
     const end = length !== undefined ? start + length : undefined;
     if (start > bytesLength) {
-        internal.errors.codeError(`extraction start ${start} is beyond length`);
+        throw new CodeError(`extraction start ${start} is beyond length`);
     }
     if (end !== undefined && end > bytesLength) {
-        internal.errors.codeError(`extraction end ${end} is beyond length`);
+        throw new CodeError(`extraction end ${end} is beyond length`);
     }
     return bytesValue.slice(start, end).asAlgoTs();
 });
 const extractUint16 = (a, b) => {
     const result = extract(a, b, 2);
-    const bytesResult = internal.primitives.BytesCls.fromCompat(result);
+    const bytesResult = BytesCls.fromCompat(result);
     return bytesResult.toUint64().asAlgoTs();
 };
 const extractUint32 = (a, b) => {
     const result = extract(a, b, 4);
-    const bytesResult = internal.primitives.BytesCls.fromCompat(result);
+    const bytesResult = BytesCls.fromCompat(result);
     return bytesResult.toUint64().asAlgoTs();
 };
 const extractUint64 = (a, b) => {
     const result = extract(a, b, 8);
-    const bytesResult = internal.primitives.BytesCls.fromCompat(result);
+    const bytesResult = BytesCls.fromCompat(result);
     return bytesResult.toUint64().asAlgoTs();
 };
 const getBit = (a, b) => {
-    const binaryString = toBinaryString(internal.primitives.isUint64(a) ? asUint64Cls(a).toBytes().asAlgoTs() : asBytes(a));
-    const index = internal.primitives.Uint64Cls.fromCompat(b).asNumber();
+    const binaryString = toBinaryString(isUint64(a) ? asUint64Cls(a).toBytes().asAlgoTs() : asBytes(a));
+    const index = Uint64Cls.fromCompat(b).asNumber();
     const adjustedIndex = asMaybeUint64Cls(a) ? binaryString.length - index - 1 : index;
     if (adjustedIndex < 0 || adjustedIndex >= binaryString.length) {
-        internal.errors.codeError(`getBit index ${index} is beyond length`);
+        throw new CodeError(`getBit index ${index} is beyond length`);
     }
-    return binaryString[adjustedIndex] === '1' ? Uint64(1) : Uint64(0);
+    return binaryString[adjustedIndex] === '1' ? 1 : 0;
 };
 const getByte = (a, b) => {
-    const bytesValue = internal.primitives.BytesCls.fromCompat(a);
-    const index = internal.primitives.Uint64Cls.fromCompat(b).asNumber();
+    const bytesValue = BytesCls.fromCompat(a);
+    const index = Uint64Cls.fromCompat(b).asNumber();
     if (index >= bytesValue.length.asNumber()) {
-        internal.errors.codeError(`getBytes index ${index} is beyond length`);
+        throw new CodeError(`getBytes index ${index} is beyond length`);
     }
     return bytesValue.at(index).toUint64().asAlgoTs();
 };
@@ -628,19 +629,19 @@ const len = (a) => {
     return asBytesCls(a).length.asAlgoTs();
 };
 const mulw = (a, b) => {
-    const uint64A = internal.primitives.Uint64Cls.fromCompat(a);
-    const uint64B = internal.primitives.Uint64Cls.fromCompat(b);
+    const uint64A = Uint64Cls.fromCompat(a);
+    const uint64B = Uint64Cls.fromCompat(b);
     const product = uint64A.asBigInt() * uint64B.asBigInt();
     return toUint128(product);
 };
 const replace = (a, b, c) => {
-    const bytesValue = internal.primitives.BytesCls.fromCompat(a);
-    const index = internal.primitives.Uint64Cls.fromCompat(b).asNumber();
-    const replacement = internal.primitives.BytesCls.fromCompat(c);
+    const bytesValue = BytesCls.fromCompat(a);
+    const index = Uint64Cls.fromCompat(b).asNumber();
+    const replacement = BytesCls.fromCompat(c);
     const valueLength = bytesValue.length.asNumber();
     const replacementLength = replacement.length.asNumber();
     if (index + replacementLength > valueLength) {
-        internal.errors.codeError(`expected value <= ${valueLength}, got: ${index + replacementLength}`);
+        throw new CodeError(`expected value <= ${valueLength}, got: ${index + replacementLength}`);
     }
     return bytesValue
         .slice(0, index)
@@ -653,13 +654,13 @@ const select = ((a, b, c) => {
     const uint64B = asMaybeUint64Cls(b);
     const bytesA = asMaybeBytesCls(a);
     const bytesB = asMaybeBytesCls(b);
-    const bigIntC = internal.primitives.Uint64Cls.fromCompat(c).asBigInt();
+    const bigIntC = Uint64Cls.fromCompat(c).asBigInt();
     return (bigIntC !== 0n ? (uint64B ?? bytesB) : (uint64A ?? bytesA)).asAlgoTs();
 });
 const setBit = ((a, b, c) => {
     const uint64Cls = asMaybeUint64Cls(a);
-    const indexParam = internal.primitives.Uint64Cls.fromCompat(b).asNumber();
-    const bit = internal.primitives.Uint64Cls.fromCompat(c).asNumber();
+    const indexParam = Uint64Cls.fromCompat(b).asNumber();
+    const bit = Uint64Cls.fromCompat(c).asNumber();
     if (uint64Cls) {
         const binaryString = toBinaryString(uint64Cls?.toBytes().asAlgoTs());
         const index = binaryString.length - indexParam - 1;
@@ -675,63 +676,63 @@ const setBit = ((a, b, c) => {
     }
 });
 const setByte = (a, b, c) => {
-    const binaryString = toBinaryString(internal.primitives.BytesCls.fromCompat(a).asAlgoTs());
-    const byteIndex = internal.primitives.Uint64Cls.fromCompat(b).asNumber();
+    const binaryString = toBinaryString(BytesCls.fromCompat(a).asAlgoTs());
+    const byteIndex = Uint64Cls.fromCompat(b).asNumber();
     const bitIndex = byteIndex * BITS_IN_BYTE;
-    const replacementNumber = internal.primitives.Uint64Cls.fromCompat(c);
+    const replacementNumber = Uint64Cls.fromCompat(c);
     const replacement = toBinaryString(replacementNumber.toBytes().at(-1).asAlgoTs());
     if (bitIndex >= binaryString.length) {
-        internal.errors.codeError(`setByte index ${byteIndex} is beyond length`);
+        throw new CodeError(`setByte index ${byteIndex} is beyond length`);
     }
     if (replacementNumber.valueOf() > MAX_UINT8) {
-        internal.errors.codeError(`setByte value ${replacementNumber.asNumber()} > ${MAX_UINT8}`);
+        throw new CodeError(`setByte value ${replacementNumber.asNumber()} > ${MAX_UINT8}`);
     }
     const updatedString = binaryString.slice(0, bitIndex) + replacement + binaryString.slice(bitIndex + replacement.length);
     const updatedBytes = binaryStringToBytes(updatedString);
     return updatedBytes.asAlgoTs();
 };
 const shl = (a, b) => {
-    const uint64A = internal.primitives.Uint64Cls.fromCompat(a);
-    const uint64B = internal.primitives.Uint64Cls.fromCompat(b);
+    const uint64A = Uint64Cls.fromCompat(a);
+    const uint64B = Uint64Cls.fromCompat(b);
     const bigIntA = uint64A.asBigInt();
     const bigIntB = uint64B.asBigInt();
     if (bigIntB >= UINT64_SIZE) {
-        internal.errors.codeError(`shl value ${bigIntB} >= ${UINT64_SIZE}`);
+        throw new CodeError(`shl value ${bigIntB} >= ${UINT64_SIZE}`);
     }
     const shifted = (bigIntA * 2n ** bigIntB) % 2n ** BigInt(UINT64_SIZE);
     return Uint64(shifted);
 };
 const shr = (a, b) => {
-    const uint64A = internal.primitives.Uint64Cls.fromCompat(a);
-    const uint64B = internal.primitives.Uint64Cls.fromCompat(b);
+    const uint64A = Uint64Cls.fromCompat(a);
+    const uint64B = Uint64Cls.fromCompat(b);
     const bigIntA = uint64A.asBigInt();
     const bigIntB = uint64B.asBigInt();
     if (bigIntB >= UINT64_SIZE) {
-        internal.errors.codeError(`shr value ${bigIntB} >= ${UINT64_SIZE}`);
+        throw new CodeError(`shr value ${bigIntB} >= ${UINT64_SIZE}`);
     }
     const shifted = bigIntA / 2n ** bigIntB;
     return Uint64(shifted);
 };
 const sqrt = (a) => {
-    const bigIntValue = internal.primitives.Uint64Cls.fromCompat(a).asBigInt();
+    const bigIntValue = Uint64Cls.fromCompat(a).asBigInt();
     const sqrtValue = squareroot(bigIntValue);
     return Uint64(sqrtValue);
 };
 const substring = (a, b, c) => {
-    const bytesValue = internal.primitives.BytesCls.fromCompat(a);
-    const start = internal.primitives.Uint64Cls.fromCompat(b).asBigInt();
-    const end = internal.primitives.Uint64Cls.fromCompat(c).asBigInt();
+    const bytesValue = BytesCls.fromCompat(a);
+    const start = Uint64Cls.fromCompat(b).asBigInt();
+    const end = Uint64Cls.fromCompat(c).asBigInt();
     if (start > end) {
-        internal.errors.codeError('substring end before start');
+        throw new CodeError('substring end before start');
     }
     if (end > bytesValue.length.asNumber()) {
-        internal.errors.codeError('substring range beyond length of string');
+        throw new CodeError('substring range beyond length of string');
     }
     return bytesValue.slice(start, end).asAlgoTs();
 };
 const JsonRef = new Proxy({}, {
     get: (_target, prop) => {
-        notImplementedError(`JsonRef.${prop.toString()}`);
+        throw new NotImplementedError(`JsonRef.${prop.toString()}`);
     },
 });
 const squareroot = (x) => {
@@ -751,19 +752,19 @@ const toUint128 = (value) => {
     return [Uint64(cf), Uint64(rest)];
 };
 const uint128ToBigInt = (a, b) => {
-    const bigIntA = internal.primitives.Uint64Cls.fromCompat(a).asBigInt();
-    const bigIntB = internal.primitives.Uint64Cls.fromCompat(b).asBigInt();
+    const bigIntA = Uint64Cls.fromCompat(a).asBigInt();
+    const bigIntB = Uint64Cls.fromCompat(b).asBigInt();
     return (bigIntA << 64n) + bigIntB;
 };
 const toBinaryString = (a) => {
-    return [...internal.primitives.BytesCls.fromCompat(a).asUint8Array()].map((x) => x.toString(2).padStart(BITS_IN_BYTE, '0')).join('');
+    return [...BytesCls.fromCompat(a).asUint8Array()].map((x) => x.toString(2).padStart(BITS_IN_BYTE, '0')).join('');
 };
 const doSetBit = (binaryString, index, bit) => {
     if (index < 0 || index >= binaryString.length) {
-        internal.errors.codeError(`setBit index ${index < 0 ? binaryString.length - index : index} is beyond length`);
+        throw new CodeError(`setBit index ${index < 0 ? binaryString.length - index : index} is beyond length`);
     }
     if (bit !== 0 && bit !== 1) {
-        internal.errors.codeError(`setBit value > 1`);
+        throw new CodeError(`setBit value > 1`);
     }
     const updatedString = binaryString.slice(0, index) + bit.toString() + binaryString.slice(index + 1);
     return binaryStringToBytes(updatedString);
@@ -841,4 +842,4 @@ const AssetParams = {
 };
 
 export { AcctParams as A, BlockData as B, extractUint64 as C, getBit as D, getByte as E, itob as F, GlobalData as G, len as H, minBalance as I, JsonRef as J, mulw as K, replace as L, select as M, setBit as N, setByte as O, shl as P, shr as Q, sqrt as R, substring as S, VoterData as V, Global as a, btoi as b, getAsset as c, getApp as d, getAccount as e, AppParams as f, getEncoder as g, AssetParams as h, Block as i, VoterParams as j, addw as k, appOptedIn as l, balance as m, base64Decode as n, bitLength as o, bsqrt as p, bzero as q, concat as r, divmodw as s, toBytes as t, divw as u, exp as v, expw as w, extract as x, extractUint16 as y, extractUint32 as z };
-//# sourceMappingURL=asset-params-CzUcFBcQ.js.map
+//# sourceMappingURL=asset-params-BfwgiVLK.js.map