@alephium/web3 1.8.2 → 1.8.3-rc.0

package/dist/_esm/src/contract/script-simulator.js

@@ -0,0 +1,754 @@
+/*
+Copyright 2018 - 2022 The Alephium Authors
+This file is part of the alephium project.
+
+The library is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with the library. If not, see <http://www.gnu.org/licenses/>.
+*/
+import { addressFromContractId } from '../address';
+import { boolCodec, unsignedTxCodec } from '../codec';
+import { lockupScriptCodec } from '../codec/lockup-script-codec';
+import { ALPH_TOKEN_ID } from '../constants';
+import { binToHex, hexToBinUnsafe } from '../utils';
+export class ScriptSimulator {
+    // This function without errors is recommended for now as the simulator does not support all instructions
+    static extractContractCalls(unsignedTx) {
+        try {
+            return this.extractContractCallsWithErrors(unsignedTx);
+        }
+        catch (e) {
+            console.debug('Error extracting contract calls from script', e);
+            return [];
+        }
+    }
+    static extractContractCallsWithErrors(unsignedTx) {
+        const unsignedTxBytes = hexToBinUnsafe(unsignedTx);
+        const decodedUnsignedTx = unsignedTxCodec.decode(unsignedTxBytes);
+        const scriptOpt = decodedUnsignedTx.statefulScript;
+        switch (scriptOpt.kind) {
+            case 'Some': {
+                return this.extractContractCallsFromScript(scriptOpt.value);
+            }
+            case 'None': {
+                return [];
+            }
+        }
+    }
+    static extractContractCallsFromScript(script) {
+        const methods = script.methods;
+        if (methods.length === 0) {
+            return [];
+        }
+        const mainMethod = methods[0];
+        return this.extractContractCallsFromMainMethod(mainMethod);
+    }
+    static extractContractCallsFromMainMethod(mainMethod) {
+        const operandStack = new Stack();
+        const localVariables = new LocalVariables();
+        const contractCalls = [];
+        const callerAddress = {
+            kind: 'Address',
+            value: { kind: 'P2PKH', value: random32Bytes() }
+        };
+        const approved = new ApprovedAccumulator();
+        for (const instr of mainMethod.instrs) {
+            switch (instr.name) {
+                case 'ConstTrue':
+                    operandStack.push({ kind: 'Bool', value: true });
+                    break;
+                case 'ConstFalse':
+                    operandStack.push({ kind: 'Bool', value: false });
+                    break;
+                case 'I256Const0':
+                    operandStack.push({ kind: 'I256', value: 0n });
+                    break;
+                case 'I256Const1':
+                    operandStack.push({ kind: 'I256', value: 1n });
+                    break;
+                case 'I256Const2':
+                    operandStack.push({ kind: 'I256', value: 2n });
+                    break;
+                case 'I256Const3':
+                    operandStack.push({ kind: 'I256', value: 3n });
+                    break;
+                case 'I256Const4':
+                    operandStack.push({ kind: 'I256', value: 4n });
+                    break;
+                case 'I256Const5':
+                    operandStack.push({ kind: 'I256', value: 5n });
+                    break;
+                case 'I256ConstN1':
+                    operandStack.push({ kind: 'I256', value: -1n });
+                    break;
+                case 'I256Const':
+                    operandStack.push({ kind: 'I256', value: instr.value });
+                    break;
+                case 'U256Const0':
+                    operandStack.push({ kind: 'U256', value: 0n });
+                    break;
+                case 'U256Const1':
+                    operandStack.push({ kind: 'U256', value: 1n });
+                    break;
+                case 'U256Const2':
+                    operandStack.push({ kind: 'U256', value: 2n });
+                    break;
+                case 'U256Const3':
+                    operandStack.push({ kind: 'U256', value: 3n });
+                    break;
+                case 'U256Const4':
+                    operandStack.push({ kind: 'U256', value: 4n });
+                    break;
+                case 'U256Const5':
+                    operandStack.push({ kind: 'U256', value: 5n });
+                    break;
+                case 'U256Const':
+                    operandStack.push({ kind: 'U256', value: instr.value });
+                    break;
+                case 'BytesConst':
+                    operandStack.push({ kind: 'ByteVec', value: instr.value });
+                    break;
+                case 'AddressConst':
+                    operandStack.push({ kind: 'Address', value: instr.value });
+                    break;
+                case 'LoadLocal':
+                    operandStack.push(localVariables.get(instr.index));
+                    break;
+                case 'StoreLocal':
+                    localVariables.set(instr.index, operandStack.pop());
+                    break;
+                case 'Pop':
+                    operandStack.pop();
+                    break;
+                case 'Dup':
+                    const val = operandStack.pop();
+                    operandStack.push(val);
+                    operandStack.push(val);
+                    break;
+                case 'Swap':
+                    const val1 = operandStack.pop();
+                    const val2 = operandStack.pop();
+                    operandStack.push(val1);
+                    operandStack.push(val2);
+                    break;
+                case 'BoolNot':
+                    const bool = operandStack.popBool();
+                    const result = unaryOp(bool, (x) => !x);
+                    operandStack.push(result);
+                case 'BoolAnd': {
+                    const bool1 = operandStack.popBool();
+                    const bool2 = operandStack.popBool();
+                    binaryOp(bool1, bool2, (x, y) => x && y, operandStack.push);
+                    break;
+                }
+                case 'BoolOr': {
+                    const bool1 = operandStack.popBool();
+                    const bool2 = operandStack.popBool();
+                    binaryOp(bool1, bool2, (x, y) => x || y, operandStack.push);
+                    break;
+                }
+                case 'BoolEq': {
+                    const bool1 = operandStack.popBool();
+                    const bool2 = operandStack.popBool();
+                    binaryOp(bool1, bool2, (x, y) => x === y, operandStack.push);
+                    break;
+                }
+                case 'BoolNeq': {
+                    const bool1 = operandStack.popBool();
+                    const bool2 = operandStack.popBool();
+                    binaryOp(bool1, bool2, (x, y) => x !== y, operandStack.push);
+                    break;
+                }
+                case 'BoolToByteVec': {
+                    const bool = operandStack.popBool();
+                    if (bool.kind === 'Symbol-Bool') {
+                        operandStack.push(bool);
+                    }
+                    else {
+                        operandStack.push({ kind: 'ByteVec', value: boolCodec.encode(bool.value) });
+                    }
+                    break;
+                }
+                case 'I256Add': {
+                    // unsafe
+                    const i256_2 = operandStack.popI256();
+                    const i256_1 = operandStack.popI256();
+                    binaryOp(i256_1, i256_2, (x, y) => x + y, operandStack.push);
+                    break;
+                }
+                case 'I256Sub': {
+                    // unsafe
+                    const i256_2 = operandStack.popI256();
+                    const i256_1 = operandStack.popI256();
+                    binaryOp(i256_1, i256_2, (x, y) => x - y, operandStack.push);
+                    break;
+                }
+                case 'I256Mul': {
+                    // unsafe
+                    const i256_2 = operandStack.popI256();
+                    const i256_1 = operandStack.popI256();
+                    binaryOp(i256_1, i256_2, (x, y) => x * y, operandStack.push);
+                    break;
+                }
+                case 'I256Div': {
+                    // unsafe
+                    const i256_2 = operandStack.popI256();
+                    const i256_1 = operandStack.popI256();
+                    binaryOp(i256_1, i256_2, (x, y) => x / y, operandStack.push);
+                    break;
+                }
+                case 'I256Eq': {
+                    // unsafe
+                    const i256_2 = operandStack.popI256();
+                    const i256_1 = operandStack.popI256();
+                    comparisonOp(i256_1, i256_2, (x, y) => x === y, operandStack.push);
+                    break;
+                }
+                case 'I256Neq': {
+                    // unsafe
+                    const i256_2 = operandStack.popI256();
+                    const i256_1 = operandStack.popI256();
+                    comparisonOp(i256_1, i256_2, (x, y) => x !== y, operandStack.push);
+                    break;
+                }
+                case 'I256Lt': {
+                    // unsafe
+                    const i256_2 = operandStack.popI256();
+                    const i256_1 = operandStack.popI256();
+                    comparisonOp(i256_1, i256_2, (x, y) => x < y, operandStack.push);
+                    break;
+                }
+                case 'I256Le': {
+                    // unsafe
+                    const i256_2 = operandStack.popI256();
+                    const i256_1 = operandStack.popI256();
+                    comparisonOp(i256_1, i256_2, (x, y) => x <= y, operandStack.push);
+                    break;
+                }
+                case 'I256Gt': {
+                    // unsafe
+                    const i256_2 = operandStack.popI256();
+                    const i256_1 = operandStack.popI256();
+                    comparisonOp(i256_1, i256_2, (x, y) => x > y, operandStack.push);
+                    break;
+                }
+                case 'I256Ge': {
+                    // unsafe
+                    const i256_2 = operandStack.popI256();
+                    const i256_1 = operandStack.popI256();
+                    comparisonOp(i256_1, i256_2, (x, y) => x >= y, operandStack.push);
+                    break;
+                }
+                case 'U256Add': {
+                    // unsafe
+                    const u256_2 = operandStack.popU256();
+                    const u256_1 = operandStack.popU256();
+                    binaryOp(u256_1, u256_2, (x, y) => x + y, operandStack.push);
+                    break;
+                }
+                case 'U256Sub': {
+                    // unsafe
+                    const u256_2 = operandStack.popU256();
+                    const u256_1 = operandStack.popU256();
+                    binaryOp(u256_1, u256_2, (x, y) => x - y, operandStack.push);
+                    break;
+                }
+                case 'U256Mul': {
+                    // unsafe
+                    const u256_2 = operandStack.popU256();
+                    const u256_1 = operandStack.popU256();
+                    binaryOp(u256_1, u256_2, (x, y) => x * y, operandStack.push);
+                    break;
+                }
+                case 'U256Div': {
+                    // unsafe
+                    const u256_2 = operandStack.popU256();
+                    const u256_1 = operandStack.popU256();
+                    binaryOp(u256_1, u256_2, (x, y) => x / y, operandStack.push);
+                    break;
+                }
+                case 'U256Eq': {
+                    // unsafe
+                    const u256_2 = operandStack.popU256();
+                    const u256_1 = operandStack.popU256();
+                    comparisonOp(u256_1, u256_2, (x, y) => x === y, operandStack.push);
+                    break;
+                }
+                case 'U256Neq': {
+                    // unsafe
+                    const u256_2 = operandStack.popU256();
+                    const u256_1 = operandStack.popU256();
+                    comparisonOp(u256_1, u256_2, (x, y) => x !== y, operandStack.push);
+                    break;
+                }
+                case 'U256Lt': {
+                    // unsafe
+                    const u256_2 = operandStack.popU256();
+                    const u256_1 = operandStack.popU256();
+                    comparisonOp(u256_1, u256_2, (x, y) => x < y, operandStack.push);
+                    break;
+                }
+                case 'U256Le': {
+                    // unsafe
+                    const u256_2 = operandStack.popU256();
+                    const u256_1 = operandStack.popU256();
+                    comparisonOp(u256_1, u256_2, (x, y) => x <= y, operandStack.push);
+                    break;
+                }
+                case 'U256Gt': {
+                    // unsafe
+                    const u256_2 = operandStack.popU256();
+                    const u256_1 = operandStack.popU256();
+                    comparisonOp(u256_1, u256_2, (x, y) => x > y, operandStack.push);
+                    break;
+                }
+                case 'U256Ge': {
+                    // unsafe
+                    const u256_2 = operandStack.popU256();
+                    const u256_1 = operandStack.popU256();
+                    comparisonOp(u256_1, u256_2, (x, y) => x >= y, operandStack.push);
+                    break;
+                }
+                case 'ByteVecEq': {
+                    const byteVec1 = operandStack.popByteVec();
+                    const byteVec2 = operandStack.popByteVec();
+                    comparisonOp(byteVec1, byteVec2, (x, y) => arrayEquals(x, y), operandStack.push);
+                    break;
+                }
+                case 'ByteVecNeq': {
+                    const byteVec1 = operandStack.popByteVec();
+                    const byteVec2 = operandStack.popByteVec();
+                    comparisonOp(byteVec1, byteVec2, (x, y) => !arrayEquals(x, y), operandStack.push);
+                    break;
+                }
+                case 'ByteVecSize': {
+                    const byteVec = operandStack.popByteVec();
+                    if (byteVec.kind === 'Symbol-ByteVec') {
+                        operandStack.push({ kind: 'Symbol-U256', value: undefined });
+                    }
+                    else {
+                        operandStack.push({ kind: 'U256', value: BigInt(byteVec.value.length) });
+                    }
+                    break;
+                }
+                case 'ByteVecConcat': {
+                    const byteVec2 = operandStack.popByteVec();
+                    const byteVec1 = operandStack.popByteVec();
+                    binaryOp(byteVec1, byteVec2, (x, y) => new Uint8Array([...x, ...y]), operandStack.push);
+                    break;
+                }
+                case 'ByteVecSlice': {
+                    const end = operandStack.popU256();
+                    const start = operandStack.popU256();
+                    const byteVec = operandStack.popByteVec();
+                    if (byteVec.kind === 'Symbol-ByteVec' || start.kind === 'Symbol-U256' || end.kind === 'Symbol-U256') {
+                        operandStack.push({ kind: 'Symbol-ByteVec', value: undefined });
+                    }
+                    else {
+                        operandStack.push({
+                            kind: 'ByteVec',
+                            value: byteVec.value.slice(Number(start.value), Number(end.value))
+                        });
+                    }
+                    break;
+                }
+                case 'AddressEq': {
+                    const address1 = operandStack.popAddress();
+                    const address2 = operandStack.popAddress();
+                    comparisonOp(address1, address2, (x, y) => arrayEquals(lockupScriptCodec.encode(x), lockupScriptCodec.encode(y)), operandStack.push);
+                    break;
+                }
+                case 'AddressNeq': {
+                    const address1 = operandStack.popAddress();
+                    const address2 = operandStack.popAddress();
+                    comparisonOp(address1, address2, (x, y) => !arrayEquals(lockupScriptCodec.encode(x), lockupScriptCodec.encode(y)), operandStack.push);
+                    break;
+                }
+                case 'AddressToByteVec': {
+                    const address = operandStack.popAddress();
+                    if (address.kind === 'Symbol-Address') {
+                        operandStack.push({ kind: 'Symbol-ByteVec', value: undefined });
+                    }
+                    else {
+                        operandStack.push({ kind: 'ByteVec', value: lockupScriptCodec.encode(address.value) });
+                    }
+                    break;
+                }
+                case 'Assert': {
+                    const bool = operandStack.popBool();
+                    if (!bool) {
+                        throw new Error('Assertion failed');
+                    }
+                    break;
+                }
+                case 'Blake2b':
+                case 'Sha256':
+                case 'Sha3':
+                case 'Keccak256': {
+                    dummyImplementation(instr.name);
+                    operandStack.popByteVec();
+                    operandStack.push({ kind: 'ByteVec', value: new Uint8Array(32) });
+                    break;
+                }
+                case 'ByteVecToAddress': {
+                    const byteVec = operandStack.popByteVec();
+                    if (byteVec.kind === 'Symbol-ByteVec') {
+                        operandStack.push({ kind: 'Symbol-Address', value: undefined });
+                    }
+                    else {
+                        operandStack.push({ kind: 'Address', value: lockupScriptCodec.decode(byteVec.value) });
+                    }
+                    break;
+                }
+                case 'Zeros': {
+                    const size = operandStack.popU256();
+                    if (size.kind === 'Symbol-U256') {
+                        operandStack.push({ kind: 'Symbol-ByteVec', value: undefined });
+                    }
+                    else {
+                        if (size.value > 4096) {
+                            throw new Error('Zeros size is too large');
+                        }
+                        operandStack.push({ kind: 'ByteVec', value: new Uint8Array(Number(size.value)) });
+                    }
+                    break;
+                }
+                case 'U256To1Byte':
+                case 'U256To2Byte':
+                case 'U256To4Byte':
+                case 'U256To8Byte':
+                case 'U256To16Byte':
+                case 'U256To32Byte': {
+                    dummyImplementation(instr.name);
+                    operandStack.popU256();
+                    operandStack.push({ kind: 'Symbol-ByteVec', value: undefined });
+                    break;
+                }
+                case 'U256From1Byte':
+                case 'U256From2Byte':
+                case 'U256From4Byte':
+                case 'U256From8Byte':
+                case 'U256From16Byte':
+                case 'U256From32Byte': {
+                    dummyImplementation(instr.name);
+                    operandStack.popByteVec();
+                    operandStack.push({ kind: 'Symbol-U256', value: undefined });
+                    break;
+                }
+                case 'CallExternal':
+                case 'CallExternalBySelector': {
+                    const contractId = operandStack.popByteVec();
+                    const returnLength = operandStack.popU256(); // method return length
+                    operandStack.popU256(); // method args length
+                    if (contractId.kind !== 'Symbol-ByteVec') {
+                        contractCalls.push({
+                            contractAddress: addressFromContractId(binToHex(contractId.value)),
+                            approvedAttoAlphAmount: approved.getApprovedAttoAlph(),
+                            approvedTokens: approved.getApprovedTokens()
+                        });
+                    }
+                    approved.reset();
+                    if (returnLength.kind !== 'Symbol-U256') {
+                        for (let i = 0; i < returnLength.value; i++) {
+                            operandStack.push({ kind: 'Symbol-Any', value: undefined });
+                        }
+                    }
+                    break;
+                }
+                case 'ContractIdToAddress': {
+                    const contractId = operandStack.popByteVec();
+                    if (contractId.kind === 'Symbol-ByteVec') {
+                        operandStack.push({ kind: 'Symbol-Address', value: undefined });
+                    }
+                    else {
+                        operandStack.push({ kind: 'Address', value: { kind: 'P2C', value: contractId.value } });
+                    }
+                    break;
+                }
+                case 'LoadLocalByIndex': {
+                    const index = operandStack.popU256();
+                    if (index.kind === 'Symbol-U256') {
+                        throw new Error('LoadLocalByIndex index is a symbol');
+                    }
+                    else {
+                        operandStack.push(localVariables.get(Number(index.value)));
+                    }
+                    break;
+                }
+                case 'StoreLocalByIndex': {
+                    const index = operandStack.popU256();
+                    if (index.kind === 'Symbol-U256') {
+                        throw new Error('StoreLocalByIndex index is a symbol');
+                    }
+                    else {
+                        localVariables.set(Number(index.value), operandStack.pop());
+                    }
+                    break;
+                }
+                case 'CallerAddress': {
+                    operandStack.push(callerAddress);
+                    break;
+                }
+                case 'ApproveAlph': {
+                    const amount = operandStack.popU256(); // amount
+                    const spender = operandStack.popAddress(); // spender
+                    if (spender.kind.startsWith('Symbol')) {
+                        approved.setUnknown(); // The spender might be the caller
+                    }
+                    else if (spender === callerAddress) {
+                        approved.addApprovedAttoAlph(amount);
+                    }
+                    break;
+                }
+                case 'ApproveToken': {
+                    const amount = operandStack.popU256(); // amount
+                    const tokenId = operandStack.popByteVec(); // token
+                    const spender = operandStack.popAddress(); // spender
+                    if (spender.kind.startsWith('Symbol')) {
+                        approved.setUnknown(); // The spender might be the caller
+                    }
+                    else if (spender === callerAddress) {
+                        approved.addApprovedToken(tokenId, amount);
+                    }
+                    break;
+                }
+                case 'CreateContractAndTransferToken': {
+                    operandStack.popAddress(); // token owner
+                }
+                case 'CreateContractWithToken': {
+                    operandStack.popU256(); // token amount
+                }
+                case 'CreateContract': {
+                    operandStack.popByteVec(); // mutable fields
+                    operandStack.popByteVec(); // immutable fields
+                    operandStack.popByteVec(); // contract code
+                    operandStack.push({ kind: 'Symbol-ByteVec', value: undefined }); // new contract id
+                    break;
+                }
+                case 'TransferAlph': {
+                    operandStack.popU256(); // amount
+                    operandStack.popAddress(); // recipient
+                    operandStack.popAddress(); // sender
+                    break;
+                }
+                case 'TransferToken': {
+                    operandStack.popU256(); // amount
+                    operandStack.popByteVec(); // token
+                    operandStack.popAddress(); // recipient
+                    operandStack.popAddress(); // sender
+                    break;
+                }
+                default:
+                    unimplemented(instr.name);
+                    break;
+            }
+        }
+        return contractCalls;
+    }
+}
+function unaryOp(x, op) {
+    if (x.kind.startsWith('Symbol')) {
+        return x;
+    }
+    else {
+        return { kind: x.kind, value: op(x.value) };
+    }
+}
+function binaryOp(x, y, op, push) {
+    const result = x.kind.startsWith('Symbol')
+        ? x
+        : y.kind.startsWith('Symbol')
+            ? y
+            : { kind: x.kind, value: op(x.value, y.value) };
+    push(result);
+}
+function comparisonOp(x, y, op, push) {
+    const result = x.kind.startsWith('Symbol') || y.kind.startsWith('Symbol')
+        ? { kind: 'Symbol-Bool', value: undefined }
+        : { kind: 'Bool', value: op(x.value, y.value) };
+    push(result);
+}
+// implement arrayEquals
+function arrayEquals(x, y) {
+    return x.length === y.length && x.every((value, index) => value === y[`${index}`]);
+}
+// generate 32 bytes array with random numbers
+function random32Bytes() {
+    const result = new Uint8Array(32);
+    for (let i = 0; i < 32; i++) {
+        result[`${i}`] = Math.floor(Math.random() * 256);
+    }
+    return result;
+}
+class Stack {
+    constructor() {
+        this.stack = [];
+        this.push = (val) => {
+            this.stack.push(val);
+        };
+        // TODO
+    }
+    pop() {
+        const result = this.stack.pop();
+        if (result === undefined) {
+            throw new Error('Stack is empty');
+        }
+        return result;
+    }
+    size() {
+        return this.stack.length;
+    }
+    checkedResult(result, expected) {
+        if (result.kind.startsWith('Symbol')) {
+            if (result.kind !== `Symbol-${expected}`) {
+                throw new Error(`Expected a ${expected} value on the stack`);
+            }
+            return result;
+        }
+        if (result.kind !== expected) {
+            throw new Error(`Expected a ${expected} value on the stack`);
+        }
+        return result;
+    }
+    popBool() {
+        const result = this.pop();
+        return this.checkedResult(result, 'Bool');
+    }
+    popI256() {
+        const result = this.pop();
+        return this.checkedResult(result, 'I256');
+    }
+    popU256() {
+        const result = this.pop();
+        return this.checkedResult(result, 'U256');
+    }
+    popByteVec() {
+        const result = this.pop();
+        return this.checkedResult(result, 'ByteVec');
+    }
+    popAddress() {
+        const result = this.pop();
+        return this.checkedResult(result, 'Address');
+    }
+}
+class LocalVariables {
+    constructor() {
+        this.locals = [];
+        // TODO
+    }
+    get(index) {
+        const result = this.locals[`${index}`];
+        if (result === undefined) {
+            throw new Error(`Local variable at index ${index} is not set`);
+        }
+        return result;
+    }
+    set(index, val) {
+        this.locals[`${index}`] = val;
+    }
+    checkedResult(result, index, expected) {
+        if (result.kind.startsWith('Symbol')) {
+            if (result.kind !== `Symbol-${expected}`) {
+                throw new Error(`Local variable at index ${index} is not a ${expected}`);
+            }
+            return result;
+        }
+        if (result.kind !== expected) {
+            throw new Error(`Local variable at index ${index} is not a ${expected}`);
+        }
+        return result;
+    }
+    getBool(index) {
+        const result = this.get(index);
+        return this.checkedResult(result, index, 'Bool');
+    }
+    getI256(index) {
+        const result = this.get(index);
+        return this.checkedResult(result, index, 'I256');
+    }
+    getU256(index) {
+        const result = this.get(index);
+        return this.checkedResult(result, index, 'U256');
+    }
+    getByteVec(index) {
+        const result = this.get(index);
+        return this.checkedResult(result, index, 'ByteVec');
+    }
+    getAddress(index) {
+        const result = this.get(index);
+        return this.checkedResult(result, index, 'Address');
+    }
+}
+function unimplemented(instrName) {
+    throw new Error(`Unimplemented instruction: ${instrName}`);
+}
+function dummyImplementation(instrName) {
+    console.debug(`Dummy implementation for instruction: ${instrName}`);
+}
+class ApprovedAccumulator {
+    constructor() {
+        this.approvedTokens = [];
+        this.reset();
+    }
+    reset() {
+        this.approvedTokens = [{ id: ALPH_TOKEN_ID, amount: 0n }];
+    }
+    setUnknown() {
+        this.approvedTokens = 'unknown';
+    }
+    getApprovedAttoAlph() {
+        if (this.approvedTokens === 'unknown') {
+            return 'unknown';
+        }
+        const approvedAttoAlph = this.approvedTokens[0].amount;
+        return approvedAttoAlph === 'unknown' ? 'unknown' : approvedAttoAlph === 0n ? undefined : approvedAttoAlph;
+    }
+    getApprovedTokens() {
+        if (this.approvedTokens === 'unknown') {
+            return 'unknown';
+        }
+        const allTokens = this.approvedTokens.slice(1);
+        return allTokens.length === 0 ? undefined : allTokens;
+    }
+    addApprovedAttoAlph(amount) {
+        this.addApprovedToken({ kind: 'ByteVec', value: hexToBinUnsafe(ALPH_TOKEN_ID) }, amount);
+    }
+    addApprovedToken(tokenId, amount) {
+        if (this.approvedTokens === 'unknown') {
+            return;
+        }
+        if (tokenId.kind === 'Symbol-ByteVec') {
+            this.approvedTokens = 'unknown';
+            return;
+        }
+        const tokenIndex = this.approvedTokens.findIndex((token) => arrayEquals(hexToBinUnsafe(token.id), tokenId.value));
+        if (tokenIndex === -1) {
+            this.approvedTokens.push({
+                id: binToHex(tokenId.value),
+                amount: amount.kind === 'Symbol-U256' ? 'unknown' : amount.value
+            });
+        }
+        else {
+            const approved = this.approvedTokens[`${tokenIndex}`];
+            if (approved.amount === 'unknown') {
+                return;
+            }
+            if (amount.kind === 'Symbol-U256') {
+                approved.amount = 'unknown';
+            }
+            else {
+                approved.amount += amount.value;
+            }
+        }
+    }
+}
+//# sourceMappingURL=script-simulator.js.map