@algorandfoundation/algorand-typescript-testing 1.0.0-alpha.16 → 1.0.0-alpha.18

package/encoders.d.ts

@@ -1,4 +1,4 @@
-import { internal } from '@algorandfoundation/algorand-typescript';
+import { bytes, internal } from '@algorandfoundation/algorand-typescript';
 import { DeliberateAny } from './typescript-helpers';
 export type TypeInfo = {
     name: string;
@@ -7,3 +7,4 @@ export type TypeInfo = {
 export type fromBytes<T> = (val: Uint8Array | internal.primitives.StubBytesCompat, typeInfo: TypeInfo, prefix?: 'none' | 'log') => T;
 export declare const encoders: Record<string, fromBytes<DeliberateAny>>;
 export declare const getEncoder: <T>(typeInfo: TypeInfo) => fromBytes<T>;
+export declare const toBytes: (val: unknown) => bytes;

package/impl/match.d.ts

@@ -0,0 +1,3 @@
+import { assertMatch, match } from '@algorandfoundation/algorand-typescript';
+export declare const matchImpl: typeof match;
+export declare const assertMatchImpl: typeof assertMatch;

package/impl/urange.d.ts

@@ -0,0 +1,2 @@
+import { internal } from '@algorandfoundation/algorand-typescript';
+export declare function urangeImpl(a: internal.primitives.StubUint64Compat, b?: internal.primitives.StubUint64Compat, c?: internal.primitives.StubUint64Compat): Generator<import("@algorandfoundation/algorand-typescript").uint64, number, unknown>;

package/index.d.ts

@@ -1 +1,2 @@
 export { TestExecutionContext } from './test-execution-context';
+export { asUint8Array as bytesToUint8Array } from './util';

package/index.mjs

@@ -1,7 +1,7 @@
-import { Bytes, Uint64, Account, internal, Base64, op, arc4, TransactionType, Asset, Application, BigUint, BaseContract, Contract } from '@algorandfoundation/algorand-typescript';
-import { a as asMaybeUint64Cls, l as lazyContext, b as asUint64, c as asBytes, t as toBytes, d as asMaybeBytesCls, e as asBigUint, B as BITS_IN_BYTE, M as MAX_BYTES_SIZE, f as asUint64Cls, g as asBytesCls, h as testInvariant, i as MAX_UINT8, j as binaryStringToBytes, U as UINT64_SIZE, n as notImplementedError, k as MAX_UINT64, m as asNumber, o as MAX_BOX_SIZE, p as asUint8Array, q as conactUint8Arrays, r as getObjectReference, s as getApplicationAddress, u as MIN_TXN_FEE, D as DEFAULT_ACCOUNT_MIN_BALANCE, v as DEFAULT_MAX_TXN_LIFE, Z as ZERO_ADDRESS, w as DEFAULT_ASSET_CREATE_MIN_BALANCE, x as DEFAULT_ASSET_OPT_IN_MIN_BALANCE, y as DEFAULT_GLOBAL_GENESIS_HASH, E as EllipticCurve, z as ecdsaPkDecompress, A as ecdsaPkRecover, C as ecdsaVerify, F as ed25519verify, G as ed25519verifyBare, H as keccak256, I as sha256, J as sha3_256, K as sha512_256, L as vrfVerify, N as combineIntoMaxBytePages, O as MAX_ITEMS_IN_LOG, P as ABI_RETURN_VALUE_LOG_PREFIX, Q as getRandomBytes, R as getArc4Encoder, S as AccountCls, T as ApplicationCls, V as AssetCls, W as arc4Encoders, X as AccountMap, Y as getGenericTypeInfo, _ as getArc4Selector, $ as isContractProxy, a0 as getContractMethodAbiMetadata, a1 as copyAbiMetadatas, a2 as getContractAbiMetadata, a3 as BytesMap, a4 as iterBigInt, a5 as Uint64Map, a6 as AssetHolding$1, a7 as asBigInt, a8 as TRANSACTION_GROUP_MAX_SIZE, a9 as getRandomBigInt, aa as AccountData, ab as ApplicationData, ac as AddressImpl, ad as UintNImpl, ae as getRandomNumber, af as MAX_UINT16, ag as MAX_UINT32, ah as MAX_UINT128, ai as MAX_UINT256, aj as MAX_UINT512, ak as DynamicBytesImpl, al as StrImpl, am as captureMethodConfig, an as DEFAULT_TEMPLATE_VAR_PREFIX } from './runtime-helpers-qRDREJih.js';
+import { Bytes, Uint64, Account, internal, BigUint, Base64, op, arc4, TransactionType, Asset, Application, BaseContract, Contract } from '@algorandfoundation/algorand-typescript';
+import { a as asMaybeUint64Cls, l as lazyContext, b as asUint64, c as asMaybeBytesCls, d as asMaybeBigUintCls, B as BytesBackedCls, U as Uint64BackedCls, e as asUint64Cls, f as encodeArc4Impl, n as nameOfType, g as getArc4Encoder, A as AccountCls, h as ApplicationCls, i as AssetCls, j as arc4Encoders, k as asUint8Array, m as asBytes, o as asBigUint, p as BITS_IN_BYTE, M as MAX_BYTES_SIZE, q as asBytesCls, t as testInvariant, r as MAX_UINT8, s as binaryStringToBytes, u as UINT64_SIZE, v as notImplementedError, w as MAX_UINT64, x as asNumber, y as MAX_BOX_SIZE, z as conactUint8Arrays, C as getObjectReference, D as getApplicationAddress, E as MIN_TXN_FEE, F as DEFAULT_ACCOUNT_MIN_BALANCE, G as DEFAULT_MAX_TXN_LIFE, Z as ZERO_ADDRESS, H as DEFAULT_ASSET_CREATE_MIN_BALANCE, I as DEFAULT_ASSET_OPT_IN_MIN_BALANCE, J as DEFAULT_GLOBAL_GENESIS_HASH, K as EllipticCurve, L as ecdsaPkDecompress, N as ecdsaPkRecover, O as ecdsaVerify, P as ed25519verify, Q as ed25519verifyBare, R as keccak256, S as sha256, T as sha3_256, V as sha512_256, W as vrfVerify, X as combineIntoMaxBytePages, Y as MAX_ITEMS_IN_LOG, _ as ABI_RETURN_VALUE_LOG_PREFIX, $ as getRandomBytes, a0 as AccountMap, a1 as getGenericTypeInfo, a2 as getArc4Selector, a3 as isContractProxy, a4 as getContractMethodAbiMetadata, a5 as copyAbiMetadatas, a6 as getContractAbiMetadata, a7 as BytesMap, a8 as iterBigInt, a9 as Uint64Map, aa as AssetHolding$1, ab as asBigInt, ac as TRANSACTION_GROUP_MAX_SIZE, ad as getRandomBigInt, ae as AccountData, af as ApplicationData, ag as AddressImpl, ah as UintNImpl, ai as getRandomNumber, aj as MAX_UINT16, ak as MAX_UINT32, al as MAX_UINT128, am as MAX_UINT256, an as MAX_UINT512, ao as DynamicBytesImpl, ap as StrImpl, aq as captureMethodConfig, ar as DEFAULT_TEMPLATE_VAR_PREFIX } from './runtime-helpers-Dc0sRTs-.js';
+import { ARC4Encoded } from '@algorandfoundation/algorand-typescript/arc4';
 import { randomBytes } from 'crypto';
-import '@algorandfoundation/algorand-typescript/arc4';
 import '@algorandfoundation/puya-ts';
 import 'js-sha512';
 import 'assert';
@@ -154,6 +154,71 @@ const AcctParams = {
     },
 };
 
+const booleanFromBytes = (val) => {
+    return internal.encodingUtil.uint8ArrayToBigInt(asUint8Array(val)) > 0n;
+};
+const bigUintFromBytes = (val) => {
+    return BigUint(internal.encodingUtil.uint8ArrayToBigInt(asUint8Array(val)));
+};
+const bytesFromBytes = (val) => {
+    return asBytes(val);
+};
+const stringFromBytes = (val) => {
+    return asBytes(val).toString();
+};
+const uint64FromBytes = (val) => {
+    return Uint64(internal.encodingUtil.uint8ArrayToBigInt(asUint8Array(val)));
+};
+const onCompletionFromBytes = (val) => {
+    return Uint64(internal.encodingUtil.uint8ArrayToBigInt(asUint8Array(val)));
+};
+const transactionTypeFromBytes = (val) => {
+    return Uint64(internal.encodingUtil.uint8ArrayToBigInt(asUint8Array(val)));
+};
+const encoders = {
+    account: AccountCls.fromBytes,
+    application: ApplicationCls.fromBytes,
+    asset: AssetCls.fromBytes,
+    boolean: booleanFromBytes,
+    biguint: bigUintFromBytes,
+    bytes: bytesFromBytes,
+    string: stringFromBytes,
+    uint64: uint64FromBytes,
+    OnCompleteAction: onCompletionFromBytes,
+    TransactionType: transactionTypeFromBytes,
+    ...arc4Encoders,
+};
+const getEncoder = (typeInfo) => {
+    return getArc4Encoder(typeInfo, encoders);
+};
+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 (val instanceof ARC4Encoded) {
+        return val.bytes;
+    }
+    if (Array.isArray(val) || typeof val === 'object') {
+        return encodeArc4Impl('', val);
+    }
+    internal.errors.internalError(`Invalid type for bytes: ${nameOfType(val)}`);
+};
+
 const AppGlobal = {
     delete(a) {
         lazyContext.ledger.setGlobalState(lazyContext.activeApplication, a, undefined);
@@ -2805,12 +2870,14 @@ class AssetConfigInnerTxn extends AssetConfigTransaction {
     /* @internal */
     constructor(fields) {
         const { assetName, unitName, url, ...rest } = mapCommonFields(fields);
-        const createdAsset = lazyContext.any.asset({
-            name: typeof assetName === 'string' ? asBytes(assetName) : assetName,
-            unitName: typeof unitName === 'string' ? asBytes(unitName) : unitName,
-            url: typeof url === 'string' ? asBytes(url) : url,
-            ...rest,
-        });
+        const createdAsset = !rest.configAsset || !asNumber(rest.configAsset.id)
+            ? lazyContext.any.asset({
+                name: typeof assetName === 'string' ? asBytes(assetName) : assetName,
+                unitName: typeof unitName === 'string' ? asBytes(unitName) : unitName,
+                url: typeof url === 'string' ? asBytes(url) : url,
+                ...rest,
+            })
+            : undefined;
         super({
             assetName: typeof assetName === 'string' ? asBytes(assetName) : assetName,
             unitName: typeof unitName === 'string' ? asBytes(unitName) : unitName,
@@ -2913,27 +2980,21 @@ function submitGroup(...transactionFields) {
     return transactionFields.map((f) => f.submit());
 }
 function payment(fields) {
-    ensureItxnGroupBegin();
     return new ItxnParams(fields, TransactionType.Payment);
 }
 function keyRegistration(fields) {
-    ensureItxnGroupBegin();
     return new ItxnParams(fields, TransactionType.KeyRegistration);
 }
 function assetConfig(fields) {
-    ensureItxnGroupBegin();
     return new ItxnParams(fields, TransactionType.AssetConfig);
 }
 function assetTransfer(fields) {
-    ensureItxnGroupBegin();
     return new ItxnParams(fields, TransactionType.AssetTransfer);
 }
 function assetFreeze(fields) {
-    ensureItxnGroupBegin();
     return new ItxnParams(fields, TransactionType.AssetFreeze);
 }
 function applicationCall(fields) {
-    ensureItxnGroupBegin();
     return new ItxnParams(fields, TransactionType.ApplicationCall);
 }
 class ItxnParams {
@@ -2942,7 +3003,9 @@ class ItxnParams {
         this.#fields = { ...fields, type };
     }
     submit() {
-        return createInnerTxn(this.#fields);
+        const innerTxn = createInnerTxn(this.#fields);
+        lazyContext.txn.activeGroup.addInnerTransactionGroup(innerTxn);
+        return innerTxn;
     }
     set(p) {
         Object.assign(this.#fields, p);
@@ -2951,49 +3014,6 @@ class ItxnParams {
         return new ItxnParams(this.#fields, this.#fields.type);
     }
 }
-const ensureItxnGroupBegin = () => {
-    if (!lazyContext.activeGroup.constructingItxnGroup.length) {
-        lazyContext.activeGroup.beginInnerTransactionGroup();
-    }
-};
-
-const booleanFromBytes = (val) => {
-    return internal.encodingUtil.uint8ArrayToBigInt(asUint8Array(val)) > 0n;
-};
-const bigUintFromBytes = (val) => {
-    return BigUint(internal.encodingUtil.uint8ArrayToBigInt(asUint8Array(val)));
-};
-const bytesFromBytes = (val) => {
-    return asBytes(val);
-};
-const stringFromBytes = (val) => {
-    return asBytes(val).toString();
-};
-const uint64FromBytes = (val) => {
-    return Uint64(internal.encodingUtil.uint8ArrayToBigInt(asUint8Array(val)));
-};
-const onCompletionFromBytes = (val) => {
-    return Uint64(internal.encodingUtil.uint8ArrayToBigInt(asUint8Array(val)));
-};
-const transactionTypeFromBytes = (val) => {
-    return Uint64(internal.encodingUtil.uint8ArrayToBigInt(asUint8Array(val)));
-};
-const encoders = {
-    account: AccountCls.fromBytes,
-    application: ApplicationCls.fromBytes,
-    asset: AssetCls.fromBytes,
-    boolean: booleanFromBytes,
-    biguint: bigUintFromBytes,
-    bytes: bytesFromBytes,
-    string: stringFromBytes,
-    uint64: uint64FromBytes,
-    OnCompleteAction: onCompletionFromBytes,
-    TransactionType: transactionTypeFromBytes,
-    ...arc4Encoders,
-};
-const getEncoder = (typeInfo) => {
-    return getArc4Encoder(typeInfo, encoders);
-};
 
 class GlobalStateCls {
     _type = GlobalStateCls.name;
@@ -3548,6 +3568,12 @@ class LedgerContext {
     addAppIdContractMap(appId, contract) {
         this.appIdContractMap.set(appId, contract);
     }
+    getAccount(address) {
+        if (this.accountDataMap.has(address)) {
+            return Account(address.bytes);
+        }
+        throw internal.errors.internalError('Unknown account, check correct testing context is active');
+    }
     getAsset(assetId) {
         if (this.assetDataMap.has(assetId)) {
             return Asset(asUint64(assetId));
@@ -3575,16 +3601,16 @@ class LedgerContext {
             return undefined;
         }
         const entries = this.applicationDataMap.entries();
-        let next = entries.next().value;
+        let next = entries.next();
         let found = false;
-        while (next && !found) {
-            found = next[1].application.approvalProgram === approvalProgram;
+        while (!next.done && !found) {
+            found = next.value[1].application.approvalProgram === approvalProgram;
             if (!found) {
-                next = entries.next().value;
+                next = entries.next();
             }
         }
-        if (found && next) {
-            const appId = asUint64(next[0]);
+        if (found && next?.value) {
+            const appId = asUint64(next.value[0]);
             if (this.applicationDataMap.has(appId)) {
                 return Application(appId);
             }
@@ -3683,15 +3709,19 @@ class LedgerContext {
     }
 }
 
+const ABI_RETURN_VALUE_LOG_PREFIX_LENGTH = asNumber(ABI_RETURN_VALUE_LOG_PREFIX.length);
 function decodeLogs(logs, decoding) {
     return logs.map((log, i) => {
+        const value = log.slice(0, ABI_RETURN_VALUE_LOG_PREFIX_LENGTH).equals(ABI_RETURN_VALUE_LOG_PREFIX)
+            ? log.slice(ABI_RETURN_VALUE_LOG_PREFIX_LENGTH)
+            : log;
         switch (decoding[i]) {
             case 'i':
-                return op.btoi(log);
+                return op.btoi(value);
             case 's':
-                return log.toString();
+                return value.toString();
             default:
-                return log;
+                return value;
         }
     });
 }
@@ -3751,13 +3781,12 @@ class TransactionContext {
     createScope(group, activeTransactionIndex) {
         const transactions = group.map((t) => (t instanceof DeferredAppCall ? t.txns : [t])).flat();
         const transactionGroup = new TransactionGroup(transactions, activeTransactionIndex);
-        const previousGroup = this.#activeGroup;
         this.#activeGroup = transactionGroup;
         const scope = ScopeGenerator(() => {
             if (this.#activeGroup?.transactions?.length) {
                 this.groups.push(this.#activeGroup);
             }
-            this.#activeGroup = previousGroup;
+            this.#activeGroup = undefined;
         });
         return {
             execute: (body) => {
@@ -3862,6 +3891,9 @@ class TransactionGroup {
         const filteredFields = Object.fromEntries(Object.entries(fields).filter(([_, value]) => value !== undefined));
         Object.assign(activeTransaction, filteredFields);
     }
+    addInnerTransactionGroup(...itxns) {
+        this.itxnGroups.push(new ItxnGroup(itxns));
+    }
     beginInnerTransactionGroup() {
         if (this.constructingItxnGroup.length) {
             internal.errors.internalError('itxn begin without itxn submit');
@@ -3890,6 +3922,9 @@ class TransactionGroup {
         this.itxnGroups.push(new ItxnGroup(itxns));
         this.constructingItxnGroup = [];
     }
+    lastItxnGroup() {
+        return this.getItxnGroup();
+    }
     getItxnGroup(index) {
         const i = index !== undefined ? asNumber(index) : undefined;
         testInvariant(this.itxnGroups.length > 0, 'no previous inner transactions');
@@ -4011,20 +4046,30 @@ class ItxnGroup {
 
 class AvmValueGenerator {
     uint64(minValue = 0n, maxValue = MAX_UINT64) {
-        if (maxValue > MAX_UINT64) {
+        const min = asBigInt(minValue);
+        const max = asBigInt(maxValue);
+        if (max > MAX_UINT64) {
             internal.errors.internalError('maxValue must be less than or equal to MAX_UINT64');
         }
-        if (minValue > maxValue) {
+        if (min > max) {
             internal.errors.internalError('minValue must be less than or equal to maxValue');
         }
-        if (minValue < 0n || maxValue < 0n) {
+        if (min < 0n || max < 0n) {
             internal.errors.internalError('minValue and maxValue must be greater than or equal to 0');
         }
-        return Uint64(getRandomBigInt(minValue, maxValue));
+        return Uint64(getRandomBigInt(min, max));
     }
     bytes(length = MAX_BYTES_SIZE) {
         return Bytes(new Uint8Array(randomBytes(length)));
     }
+    string(length = 11) {
+        const setLength = 11;
+        return Array(Math.ceil(length / setLength))
+            .fill(0)
+            .map(() => Math.random().toString(36).substring(2))
+            .join('')
+            .substring(0, length);
+    }
     account(input) {
         const account = input?.address ?? Account(getRandomBytes(32).asAlgoTs());
         if (input?.address && lazyContext.ledger.accountDataMap.has(account)) {
@@ -4369,5 +4414,5 @@ class TestExecutionContext {
     }
 }
 
-export { TestExecutionContext };
+export { TestExecutionContext, asUint8Array as bytesToUint8Array };
 //# sourceMappingURL=index.mjs.map