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

package/asset-params-CzUcFBcQ.js

@@ -0,0 +1,844 @@
+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';
+
+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)}`);
+};
+
+class BlockData {
+    seed;
+    timestamp;
+    proposer;
+    feesCollected;
+    bonus;
+    branch;
+    feeSink;
+    protocol;
+    txnCounter;
+    proposerPayout;
+    constructor() {
+        this.seed = getRandomBytes(32).asAlgoTs();
+        this.timestamp = asUint64(Date.now());
+        this.proposer = Account();
+        this.feesCollected = Uint64(0);
+        this.bonus = Uint64(0);
+        this.branch = getRandomBytes(32).asAlgoTs();
+        this.feeSink = Account();
+        this.protocol = getRandomBytes(32).asAlgoTs();
+        this.txnCounter = Uint64(0);
+        this.proposerPayout = Uint64(0);
+    }
+}
+const Block = {
+    blkSeed: function (a) {
+        return lazyContext.ledger.getBlockData(a).seed;
+    },
+    blkTimestamp: function (a) {
+        return lazyContext.ledger.getBlockData(a).timestamp;
+    },
+    blkProposer: function (a) {
+        return lazyContext.ledger.getBlockData(a).proposer;
+    },
+    blkFeesCollected: function (a) {
+        return lazyContext.ledger.getBlockData(a).feesCollected;
+    },
+    blkBonus: function (a) {
+        return lazyContext.ledger.getBlockData(a).bonus;
+    },
+    blkBranch: function (a) {
+        return lazyContext.ledger.getBlockData(a).branch;
+    },
+    blkFeeSink: function (a) {
+        return lazyContext.ledger.getBlockData(a).feeSink;
+    },
+    blkProtocol: function (a) {
+        return lazyContext.ledger.getBlockData(a).protocol;
+    },
+    blkTxnCounter: function (a) {
+        return lazyContext.ledger.getBlockData(a).txnCounter;
+    },
+    blkProposerPayout: function (a) {
+        return lazyContext.ledger.getBlockData(a).proposerPayout;
+    },
+};
+
+class GlobalData {
+    minTxnFee;
+    minBalance;
+    maxTxnLife;
+    zeroAddress;
+    logicSigVersion;
+    round;
+    latestTimestamp;
+    groupId;
+    callerApplicationId;
+    assetCreateMinBalance;
+    assetOptInMinBalance;
+    genesisHash;
+    opcodeBudget;
+    payoutsEnabled;
+    payoutsGoOnlineFee;
+    payoutsPercent;
+    payoutsMinBalance;
+    constructor() {
+        this.minTxnFee = Uint64(MIN_TXN_FEE);
+        this.minBalance = Uint64(DEFAULT_ACCOUNT_MIN_BALANCE);
+        this.maxTxnLife = Uint64(DEFAULT_MAX_TXN_LIFE);
+        this.zeroAddress = Account(ZERO_ADDRESS);
+        this.callerApplicationId = Uint64(0);
+        this.assetCreateMinBalance = Uint64(DEFAULT_ASSET_CREATE_MIN_BALANCE);
+        this.assetOptInMinBalance = Uint64(DEFAULT_ASSET_OPT_IN_MIN_BALANCE);
+        this.genesisHash = DEFAULT_GLOBAL_GENESIS_HASH;
+        this.payoutsEnabled = false;
+        this.payoutsGoOnlineFee = Uint64(0);
+        this.payoutsPercent = Uint64(0);
+        this.payoutsMinBalance = Uint64(0);
+    }
+}
+const getGlobalData = () => {
+    return lazyContext.ledger.globalData;
+};
+const getMissingValueErrorMessage = (name) => `'Global' object has no value set for attribute named '${name}'. Use \`context.ledger.patchGlobalData({${name}: your_value})\` to set the value in your test setup."`;
+const Global = {
+    /**
+     * microalgos
+     */
+    get minTxnFee() {
+        return getGlobalData().minTxnFee;
+    },
+    /**
+     * microalgos
+     */
+    get minBalance() {
+        return getGlobalData().minBalance;
+    },
+    /**
+     * rounds
+     */
+    get maxTxnLife() {
+        return getGlobalData().maxTxnLife;
+    },
+    /**
+     * 32 byte address of all zero bytes
+     */
+    get zeroAddress() {
+        return getGlobalData().zeroAddress;
+    },
+    /**
+     * Number of transactions in this atomic transaction group. At least 1
+     */
+    get groupSize() {
+        const currentTransactionGroup = lazyContext.activeGroup.transactions;
+        return Uint64(currentTransactionGroup.length);
+    },
+    /**
+     * Maximum supported version
+     */
+    get logicSigVersion() {
+        const data = getGlobalData();
+        if (data.logicSigVersion !== undefined)
+            return data.logicSigVersion;
+        throw new internal.errors.InternalError(getMissingValueErrorMessage('logicSigVersion'));
+    },
+    /**
+     * Current round number. ApplicationType mode only.
+     */
+    get round() {
+        const data = getGlobalData();
+        if (data.round !== undefined)
+            return data.round;
+        return Uint64(lazyContext.txn.groups.length + 1);
+    },
+    /**
+     * Last confirmed block UNIX timestamp. Fails if negative. ApplicationType mode only.
+     */
+    get latestTimestamp() {
+        const data = getGlobalData();
+        if (data.latestTimestamp !== undefined)
+            return data.latestTimestamp;
+        return Uint64(lazyContext.activeGroup.latestTimestamp);
+    },
+    /**
+     * ID of current application executing. ApplicationType mode only.
+     */
+    get currentApplicationId() {
+        return lazyContext.activeApplication;
+    },
+    /**
+     * Address of the creator of the current application. ApplicationType mode only.
+     */
+    get creatorAddress() {
+        const app = lazyContext.activeApplication;
+        return app.creator;
+    },
+    /**
+     * Address that the current application controls. ApplicationType mode only.
+     */
+    get currentApplicationAddress() {
+        return this.currentApplicationId.address;
+    },
+    /**
+     * ID of the transaction group. 32 zero bytes if the transaction is not part of a group.
+     */
+    get groupId() {
+        const data = getGlobalData();
+        if (data.groupId !== undefined)
+            return data.groupId;
+        const reference = getObjectReference(lazyContext.activeGroup);
+        const referenceBytes = Bytes(internal.encodingUtil.bigIntToUint8Array(reference));
+        return sha256(referenceBytes);
+    },
+    /**
+     * The remaining cost that can be spent by opcodes in this program.
+     */
+    get opcodeBudget() {
+        const data = getGlobalData();
+        if (data.opcodeBudget !== undefined)
+            return data.opcodeBudget;
+        throw new internal.errors.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.
+     */
+    get callerApplicationId() {
+        return getGlobalData().callerApplicationId;
+    },
+    /**
+     * The application address of the application that called this application. ZeroAddress if this application is at the top-level. ApplicationType mode only.
+     */
+    get callerApplicationAddress() {
+        return getApplicationAddress(this.callerApplicationId);
+    },
+    /**
+     * The additional minimum balance required to create (and opt-in to) an asset.
+     */
+    get assetCreateMinBalance() {
+        return getGlobalData().assetCreateMinBalance;
+    },
+    /**
+     * The additional minimum balance required to opt-in to an asset.
+     */
+    get assetOptInMinBalance() {
+        return getGlobalData().assetOptInMinBalance;
+    },
+    /**
+     * The Genesis Hash for the network.
+     */
+    get genesisHash() {
+        return getGlobalData().genesisHash;
+    },
+    /**
+     * Whether block proposal payouts are enabled.
+     * Min AVM version: 11
+     */
+    get payoutsEnabled() {
+        return getGlobalData().payoutsEnabled;
+    },
+    /**
+     * The fee required in a keyreg transaction to make an account incentive eligible.
+     * Min AVM version: 11
+     */
+    get payoutsGoOnlineFee() {
+        return getGlobalData().payoutsGoOnlineFee;
+    },
+    /**
+     * The percentage of transaction fees in a block that can be paid to the block proposer.
+     * Min AVM version: 11
+     */
+    get payoutsPercent() {
+        return getGlobalData().payoutsPercent;
+    },
+    /**
+     * The minimum algo balance an account must have in the agreement round to receive block payouts in the proposal round.
+     * Min AVM version: 11
+     */
+    get payoutsMinBalance() {
+        return getGlobalData().payoutsMinBalance;
+    },
+    /**
+     * The maximum algo balance an account can have in the agreement round to receive block payouts in the proposal round.
+     * Min AVM version: 11
+     */
+    get payoutsMaxBalance() {
+        return getGlobalData().payoutsMinBalance;
+    },
+};
+
+const resolveAppIndex = (appIdOrIndex) => {
+    const input = asUint64(appIdOrIndex);
+    if (input >= 1001) {
+        return input;
+    }
+    const txn = lazyContext.activeGroup.activeTransaction;
+    return txn.apps(input).id;
+};
+const getApp = (app) => {
+    try {
+        const appId = asMaybeUint64Cls(app);
+        if (appId !== undefined) {
+            return lazyContext.ledger.getApplication(resolveAppIndex(appId));
+        }
+        return app;
+    }
+    catch {
+        return undefined;
+    }
+};
+const AppParams = {
+    appApprovalProgram(a) {
+        const app = getApp(a);
+        return app === undefined ? [Bytes(), false] : [app.approvalProgram, true];
+    },
+    appClearStateProgram(a) {
+        const app = getApp(a);
+        return app === undefined ? [Bytes(), false] : [app.clearStateProgram, true];
+    },
+    appGlobalNumUint(a) {
+        const app = getApp(a);
+        return app === undefined ? [Uint64(0), false] : [app.globalNumUint, true];
+    },
+    appGlobalNumByteSlice(a) {
+        const app = getApp(a);
+        return app === undefined ? [Uint64(0), false] : [app.globalNumBytes, true];
+    },
+    appLocalNumUint(a) {
+        const app = getApp(a);
+        return app === undefined ? [Uint64(0), false] : [app.localNumUint, true];
+    },
+    appLocalNumByteSlice(a) {
+        const app = getApp(a);
+        return app === undefined ? [Uint64(0), false] : [app.localNumBytes, true];
+    },
+    appExtraProgramPages(a) {
+        const app = getApp(a);
+        return app === undefined ? [Uint64(0), false] : [app.extraProgramPages, true];
+    },
+    appCreator(a) {
+        const app = getApp(a);
+        return app === undefined ? [Account(), false] : [app.creator, true];
+    },
+    appAddress(a) {
+        const app = getApp(a);
+        return app === undefined ? [Account(), false] : [app.address, true];
+    },
+};
+
+const getAccount = (acct) => {
+    const acctId = asMaybeUint64Cls(acct);
+    if (acctId !== undefined) {
+        const activeTxn = lazyContext.activeGroup.activeTransaction;
+        return activeTxn.accounts(acctId.asAlgoTs());
+    }
+    return acct;
+};
+const balance = (a) => {
+    const acct = getAccount(a);
+    return acct.balance;
+};
+const minBalance = (a) => {
+    const acct = getAccount(a);
+    return acct.minBalance;
+};
+const appOptedIn = (a, b) => {
+    const account = getAccount(a);
+    const app = getApp(b);
+    if (account === undefined || app === undefined) {
+        return false;
+    }
+    return account.isOptedIn(app);
+};
+const AcctParams = {
+    acctBalance(a) {
+        const acct = getAccount(a);
+        return [acct.balance, acct.balance !== 0];
+    },
+    acctMinBalance(a) {
+        const acct = getAccount(a);
+        return [acct.minBalance, acct.balance !== 0];
+    },
+    acctAuthAddr(a) {
+        const acct = getAccount(a);
+        return [acct.authAddress, acct.balance !== 0];
+    },
+    acctTotalNumUint(a) {
+        const acct = getAccount(a);
+        return [acct.totalNumUint, acct.balance !== 0];
+    },
+    acctTotalNumByteSlice(a) {
+        const acct = getAccount(a);
+        return [acct.totalNumByteSlice, acct.balance !== 0];
+    },
+    acctTotalExtraAppPages(a) {
+        const acct = getAccount(a);
+        return [acct.totalExtraAppPages, acct.balance !== 0];
+    },
+    acctTotalAppsCreated(a) {
+        const acct = getAccount(a);
+        return [acct.totalAppsCreated, acct.balance !== 0];
+    },
+    acctTotalAppsOptedIn(a) {
+        const acct = getAccount(a);
+        return [acct.totalAppsOptedIn, acct.balance !== 0];
+    },
+    acctTotalAssetsCreated(a) {
+        const acct = getAccount(a);
+        return [acct.totalAssetsCreated, acct.balance !== 0];
+    },
+    acctTotalAssets(a) {
+        const acct = getAccount(a);
+        return [acct.totalAssets, acct.balance !== 0];
+    },
+    acctTotalBoxes(a) {
+        const acct = getAccount(a);
+        return [acct.totalBoxes, acct.balance !== 0];
+    },
+    acctTotalBoxBytes(a) {
+        const acct = getAccount(a);
+        return [acct.totalBoxBytes, acct.balance !== 0];
+    },
+    acctIncentiveEligible: function (a) {
+        const acct = getAccount(a);
+        const accountData = lazyContext.ledger.accountDataMap.get(acct);
+        return [accountData?.incentiveEligible ?? false, acct.balance !== 0];
+    },
+    acctLastProposed: function (a) {
+        const acct = getAccount(a);
+        const accountData = lazyContext.ledger.accountDataMap.get(acct);
+        return [accountData?.lastProposed ?? Global.round, acct.balance !== 0];
+    },
+    acctLastHeartbeat: function (a) {
+        const acct = getAccount(a);
+        const accountData = lazyContext.ledger.accountDataMap.get(acct);
+        return [accountData?.lastHeartbeat ?? Global.round, acct.balance !== 0];
+    },
+};
+
+class VoterData {
+    balance;
+    incentiveEligible;
+    constructor() {
+        this.balance = 0;
+        this.incentiveEligible = false;
+    }
+}
+const getVoterData = (a) => {
+    const acct = getAccount(a);
+    return lazyContext.getVoterData(acct);
+};
+const VoterParams = {
+    voterBalance: function (a) {
+        const data = getVoterData(a);
+        return [data.balance, data.balance !== 0];
+    },
+    voterIncentiveEligible: function (a) {
+        const data = getVoterData(a);
+        return [data.incentiveEligible, data.balance !== 0];
+    },
+};
+
+const addw = (a, b) => {
+    const uint64A = internal.primitives.Uint64Cls.fromCompat(a);
+    const uint64B = internal.primitives.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 stringValue = bytesValue.toString();
+    const bufferResult = Buffer.from(stringValue, encoding);
+    if (bufferResult.toString(encoding) !== stringValue) {
+        internal.errors.avmError('illegal base64 data');
+    }
+    const uint8ArrayResult = new Uint8Array(bufferResult);
+    return Bytes(uint8ArrayResult);
+};
+const bitLength = (a) => {
+    const uint64Cls = asMaybeUint64Cls(a);
+    const bigUintCls = asMaybeBytesCls(a)?.toBigUint();
+    const bigIntValue = (uint64Cls?.asBigInt() ?? bigUintCls?.asBigInt());
+    const binaryValue = bigIntValue === 0n ? '' : bigIntValue.toString(2);
+    return Uint64(binaryValue.length);
+};
+const bsqrt = (a) => {
+    const bigUintClsValue = internal.primitives.BigUintCls.fromCompat(a);
+    const bigintValue = internal.primitives.checkBigUint(bigUintClsValue.asBigInt());
+    const sqrtValue = squareroot(bigintValue);
+    return asBigUint(sqrtValue);
+};
+const btoi = (a) => {
+    const bytesValue = internal.primitives.BytesCls.fromCompat(a);
+    if (bytesValue.length.asAlgoTs() > BITS_IN_BYTE) {
+        internal.errors.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();
+    if (size > MAX_BYTES_SIZE) {
+        internal.errors.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);
+    return bytesA.concat(bytesB).asAlgoTs();
+};
+const divmodw = (a, b, c, d) => {
+    const i = uint128ToBigInt(a, b);
+    const j = uint128ToBigInt(c, d);
+    const div = i / j;
+    const mod = i % j;
+    return [...toUint128(div), ...toUint128(mod)];
+};
+const divw = (a, b, c) => {
+    const i = uint128ToBigInt(a, b);
+    const j = internal.primitives.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();
+    if (base === 0n && exponent === 0n) {
+        throw internal.errors.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();
+    if (base === 0n && exponent === 0n) {
+        throw internal.errors.codeError('0 ** 0 is undefined');
+    }
+    return toUint128(base ** exponent);
+};
+const extract = ((a, b, c) => {
+    const bytesValue = internal.primitives.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 end = length !== undefined ? start + length : undefined;
+    if (start > bytesLength) {
+        internal.errors.codeError(`extraction start ${start} is beyond length`);
+    }
+    if (end !== undefined && end > bytesLength) {
+        internal.errors.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);
+    return bytesResult.toUint64().asAlgoTs();
+};
+const extractUint32 = (a, b) => {
+    const result = extract(a, b, 4);
+    const bytesResult = internal.primitives.BytesCls.fromCompat(result);
+    return bytesResult.toUint64().asAlgoTs();
+};
+const extractUint64 = (a, b) => {
+    const result = extract(a, b, 8);
+    const bytesResult = internal.primitives.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 adjustedIndex = asMaybeUint64Cls(a) ? binaryString.length - index - 1 : index;
+    if (adjustedIndex < 0 || adjustedIndex >= binaryString.length) {
+        internal.errors.codeError(`getBit index ${index} is beyond length`);
+    }
+    return binaryString[adjustedIndex] === '1' ? Uint64(1) : Uint64(0);
+};
+const getByte = (a, b) => {
+    const bytesValue = internal.primitives.BytesCls.fromCompat(a);
+    const index = internal.primitives.Uint64Cls.fromCompat(b).asNumber();
+    if (index >= bytesValue.length.asNumber()) {
+        internal.errors.codeError(`getBytes index ${index} is beyond length`);
+    }
+    return bytesValue.at(index).toUint64().asAlgoTs();
+};
+const itob = (a) => {
+    return asUint64Cls(a).toBytes().asAlgoTs();
+};
+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 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 valueLength = bytesValue.length.asNumber();
+    const replacementLength = replacement.length.asNumber();
+    if (index + replacementLength > valueLength) {
+        internal.errors.codeError(`expected value <= ${valueLength}, got: ${index + replacementLength}`);
+    }
+    return bytesValue
+        .slice(0, index)
+        .concat(replacement)
+        .concat(bytesValue.slice(index + replacementLength, valueLength))
+        .asAlgoTs();
+};
+const select = ((a, b, c) => {
+    const uint64A = asMaybeUint64Cls(a);
+    const uint64B = asMaybeUint64Cls(b);
+    const bytesA = asMaybeBytesCls(a);
+    const bytesB = asMaybeBytesCls(b);
+    const bigIntC = internal.primitives.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();
+    if (uint64Cls) {
+        const binaryString = toBinaryString(uint64Cls?.toBytes().asAlgoTs());
+        const index = binaryString.length - indexParam - 1;
+        const newBytes = doSetBit(binaryString, index, bit);
+        return newBytes.toUint64().asAlgoTs();
+    }
+    else {
+        const bytesCls = asMaybeBytesCls(a);
+        testInvariant(bytesCls, 'a must be uint64 or bytes');
+        const binaryString = toBinaryString(bytesCls.asAlgoTs());
+        const newBytes = doSetBit(binaryString, indexParam, bit);
+        return newBytes.asAlgoTs();
+    }
+});
+const setByte = (a, b, c) => {
+    const binaryString = toBinaryString(internal.primitives.BytesCls.fromCompat(a).asAlgoTs());
+    const byteIndex = internal.primitives.Uint64Cls.fromCompat(b).asNumber();
+    const bitIndex = byteIndex * BITS_IN_BYTE;
+    const replacementNumber = internal.primitives.Uint64Cls.fromCompat(c);
+    const replacement = toBinaryString(replacementNumber.toBytes().at(-1).asAlgoTs());
+    if (bitIndex >= binaryString.length) {
+        internal.errors.codeError(`setByte index ${byteIndex} is beyond length`);
+    }
+    if (replacementNumber.valueOf() > MAX_UINT8) {
+        internal.errors.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 bigIntA = uint64A.asBigInt();
+    const bigIntB = uint64B.asBigInt();
+    if (bigIntB >= UINT64_SIZE) {
+        internal.errors.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 bigIntA = uint64A.asBigInt();
+    const bigIntB = uint64B.asBigInt();
+    if (bigIntB >= UINT64_SIZE) {
+        internal.errors.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 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();
+    if (start > end) {
+        internal.errors.codeError('substring end before start');
+    }
+    if (end > bytesValue.length.asNumber()) {
+        internal.errors.codeError('substring range beyond length of string');
+    }
+    return bytesValue.slice(start, end).asAlgoTs();
+};
+const JsonRef = new Proxy({}, {
+    get: (_target, prop) => {
+        notImplementedError(`JsonRef.${prop.toString()}`);
+    },
+});
+const squareroot = (x) => {
+    let lo = 0n, hi = x;
+    while (lo <= hi) {
+        const mid = (lo + hi) / 2n;
+        if (mid * mid > x)
+            hi = mid - 1n;
+        else
+            lo = mid + 1n;
+    }
+    return hi;
+};
+const toUint128 = (value) => {
+    const cf = value >> 64n;
+    const rest = value & MAX_UINT64;
+    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();
+    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('');
+};
+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`);
+    }
+    if (bit !== 0 && bit !== 1) {
+        internal.errors.codeError(`setBit value > 1`);
+    }
+    const updatedString = binaryString.slice(0, index) + bit.toString() + binaryString.slice(index + 1);
+    return binaryStringToBytes(updatedString);
+};
+
+const resolveAssetIndex = (assetIdOrIndex) => {
+    const input = asUint64(assetIdOrIndex);
+    if (input >= 1001) {
+        return input;
+    }
+    const txn = lazyContext.activeGroup.activeTransaction;
+    return txn.assets(input).id;
+};
+const getAsset = (asset) => {
+    try {
+        const assetId = asMaybeUint64Cls(asset);
+        if (assetId !== undefined) {
+            return lazyContext.ledger.getAsset(resolveAssetIndex(assetId));
+        }
+        return asset;
+    }
+    catch {
+        return undefined;
+    }
+};
+const AssetParams = {
+    assetTotal(a) {
+        const asset = getAsset(a);
+        return asset === undefined ? [Uint64(0), false] : [asset.total, true];
+    },
+    assetDecimals(a) {
+        const asset = getAsset(a);
+        return asset === undefined ? [Uint64(0), false] : [asset.decimals, true];
+    },
+    assetDefaultFrozen(a) {
+        const asset = getAsset(a);
+        return asset === undefined ? [false, false] : [asset.defaultFrozen, true];
+    },
+    assetUnitName(a) {
+        const asset = getAsset(a);
+        return asset === undefined ? [Bytes(), false] : [asset.unitName, true];
+    },
+    assetName(a) {
+        const asset = getAsset(a);
+        return asset === undefined ? [Bytes(), false] : [asset.name, true];
+    },
+    assetUrl(a) {
+        const asset = getAsset(a);
+        return asset === undefined ? [Bytes(), false] : [asset.url, true];
+    },
+    assetMetadataHash(a) {
+        const asset = getAsset(a);
+        return asset === undefined ? [Bytes(), false] : [asset.metadataHash, true];
+    },
+    assetManager(a) {
+        const asset = getAsset(a);
+        return asset === undefined ? [Account(), false] : [asset.manager, true];
+    },
+    assetReserve(a) {
+        const asset = getAsset(a);
+        return asset === undefined ? [Account(), false] : [asset.reserve, true];
+    },
+    assetFreeze(a) {
+        const asset = getAsset(a);
+        return asset === undefined ? [Account(), false] : [asset.freeze, true];
+    },
+    assetClawback(a) {
+        const asset = getAsset(a);
+        return asset === undefined ? [Account(), false] : [asset.clawback, true];
+    },
+    assetCreator(a) {
+        const asset = getAsset(a);
+        return asset === undefined ? [Account(), false] : [asset.creator, true];
+    },
+};
+
+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