@alephium/web3 1.3.0 → 1.5.0

package/dist/src/codec/val.js

@@ -0,0 +1,33 @@
+"use strict";
+/*
+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/>.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.valsCodec = exports.valCodec = void 0;
+const compact_int_codec_1 = require("./compact-int-codec");
+const bytestring_codec_1 = require("./bytestring-codec");
+const codec_1 = require("./codec");
+const lockup_script_codec_1 = require("./lockup-script-codec");
+const array_codec_1 = require("./array-codec");
+exports.valCodec = new codec_1.EnumCodec('val', {
+    Bool: codec_1.boolCodec,
+    I256: compact_int_codec_1.i256Codec,
+    U256: compact_int_codec_1.u256Codec,
+    ByteVec: bytestring_codec_1.byteStringCodec,
+    Address: lockup_script_codec_1.lockupScriptCodec
+});
+exports.valsCodec = new array_codec_1.ArrayCodec(exports.valCodec);

package/dist/src/contract/contract.d.ts

@@ -182,6 +182,7 @@ export declare abstract class ContractFactory<I extends ContractInstance, F exte
     constructor(contract: Contract);
     abstract at(address: string): I;
     deploy(signer: SignerProvider, deployParams: DeployContractParams<F>): Promise<DeployContractResult<I>>;
+    deployTemplate(signer: SignerProvider): Promise<DeployContractResult<I>>;
     stateForTest(initFields: F, asset?: Asset, address?: string): ContractState<F>;
 }
 export declare class ExecutableScript<P extends Fields = Fields, R extends Val | null = null> {

package/dist/src/contract/contract.js

@@ -60,7 +60,8 @@ exports.DEFAULT_NODE_COMPILER_OPTIONS = {
     ignoreUnusedFieldsWarnings: false,
     ignoreUnusedPrivateFunctionsWarnings: false,
     ignoreUpdateFieldsCheckWarnings: false,
-    ignoreCheckExternalCallerWarnings: false
+    ignoreCheckExternalCallerWarnings: false,
+    ignoreUnusedFunctionReturnWarnings: false
 };
 exports.DEFAULT_COMPILER_OPTIONS = { errorOnWarnings: true, ...exports.DEFAULT_NODE_COMPILER_OPTIONS };
 class Struct {
@@ -627,6 +628,11 @@ class ContractFactory {
             contractInstance: this.at(result.contractAddress)
         };
     }
+    async deployTemplate(signer) {
+        return this.deploy(signer, {
+            initialFields: this.contract.getInitialFieldsWithDefaultValues()
+        });
+    }
     // This is used for testing contract functions
     stateForTest(initFields, asset, address) {
         const newAsset = {
@@ -1068,8 +1074,8 @@ exports.callMethod = callMethod;
 async function signExecuteMethod(contract, instance, methodName, params) {
     const methodIndex = contract.contract.getMethodIndex(methodName);
     const functionSig = contract.contract.functions[methodIndex];
-    const usePreapprovedAssets = contract.contract.decodedMethods[methodIndex].usePreapprovedAssets;
-    const bytecodeTemplate = getBytecodeTemplate(methodIndex, usePreapprovedAssets, functionSig, contract.contract.structs, params.attoAlphAmount, params.tokens);
+    const methodUsePreapprovedAssets = contract.contract.decodedMethods[methodIndex].usePreapprovedAssets;
+    const bytecodeTemplate = getBytecodeTemplate(methodIndex, methodUsePreapprovedAssets, functionSig, contract.contract.structs, params.attoAlphAmount, params.tokens);
     const fieldsSig = toFieldsSig(contract.contract.name, functionSig);
     const bytecode = ralph.buildScriptByteCode(bytecodeTemplate, { __contract__: instance.contractId, ...params.args }, fieldsSig, contract.contract.structs);
     const signer = params.signer;
@@ -1086,16 +1092,20 @@ async function signExecuteMethod(contract, instance, methodName, params) {
     return await signer.signAndSubmitExecuteScriptTx(signerParams);
 }
 exports.signExecuteMethod = signExecuteMethod;
-function getBytecodeTemplate(methodIndex, usePreapprovedAssets, functionSig, structs, attoAlphAmount, tokens) {
+function getBytecodeTemplate(methodIndex, methodUsePreapprovedAssets, functionSig, structs, attoAlphAmount, tokens) {
     // For the default TxScript main function
     const numberOfMethods = '01';
     const isPublic = '01';
-    const modifier = usePreapprovedAssets ? '03' : '00';
+    const scriptUseApprovedAssets = attoAlphAmount !== undefined || tokens !== undefined;
+    const modifier = scriptUseApprovedAssets ? '03' : '00';
     const argsLength = '00';
     const returnsLength = '00';
+    if (methodUsePreapprovedAssets && !scriptUseApprovedAssets) {
+        throw new Error('The contract call requires preapproved assets but none are provided');
+    }
     const [templateVarStoreLocalInstrs, templateVarsLength] = getTemplateVarStoreLocalInstrs(functionSig, structs);
-    const approveAlphInstrs = getApproveAlphInstrs(usePreapprovedAssets ? attoAlphAmount : undefined);
-    const approveTokensInstrs = getApproveTokensInstrs(usePreapprovedAssets ? tokens : undefined);
+    const approveAlphInstrs = getApproveAlphInstrs(methodUsePreapprovedAssets ? attoAlphAmount : undefined);
+    const approveTokensInstrs = getApproveTokensInstrs(methodUsePreapprovedAssets ? tokens : undefined);
     const callerInstrs = getCallAddressInstrs(approveAlphInstrs.length / 2 + approveTokensInstrs.length / 3);
     // First template var is the contract
     const functionArgsNum = encodeU256Const(BigInt(templateVarsLength - 1));
@@ -1146,10 +1156,7 @@ function getApproveTokensInstrs(tokens) {
     if (tokens) {
         tokens.forEach((token) => {
             const tokenIdBin = (0, utils_1.hexToBinUnsafe)(token.id);
-            approveTokensInstrs.push(encodeInstr((0, codec_1.ByteConst)({
-                length: codec_1.compactSignedIntCodec.fromI32(tokenIdBin.length),
-                value: tokenIdBin
-            })));
+            approveTokensInstrs.push(encodeInstr((0, codec_1.BytesConst)(tokenIdBin)));
             approveTokensInstrs.push(encodeU256Const(BigInt(token.amount)));
             approveTokensInstrs.push(encodeInstr(codec_1.ApproveToken));
         });
@@ -1218,7 +1225,7 @@ function encodeLoadLocalInstr(index) {
     return encodeInstr((0, codec_1.LoadLocal)(index));
 }
 function encodeI32(value) {
-    return (0, utils_1.binToHex)(codec_1.compactSignedIntCodec.encodeI32(value));
+    return (0, utils_1.binToHex)(codec_1.i32Codec.encode(value));
 }
 function encodeU256Const(value) {
     if (value < 0) {
@@ -1228,7 +1235,7 @@ function encodeU256Const(value) {
         return (BigInt(0x0c) + value).toString(16).padStart(2, '0');
     }
     else {
-        return encodeInstr((0, codec_1.U256Const)(codec_1.compactUnsignedIntCodec.fromU256(BigInt(value))));
+        return encodeInstr((0, codec_1.U256Const)(value));
     }
 }
 function encodeInstr(instr) {

package/dist/src/contract/index.d.ts

@@ -1,3 +1,4 @@
 export * from './ralph';
 export * from './contract';
 export * from './events';
+export * from './script-simulator';

package/dist/src/contract/index.js

@@ -34,3 +34,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./ralph"), exports);
 __exportStar(require("./contract"), exports);
 __exportStar(require("./events"), exports);
+__exportStar(require("./script-simulator"), exports);

package/dist/src/contract/ralph.d.ts

@@ -1,10 +1,6 @@
 import { Val } from '../api';
 import { HexString } from '../utils';
 import { Fields, FieldsSig, Struct } from './contract';
-export declare function encodeBool(bool: boolean): Uint8Array;
-export declare function decodeBool(bytes: Uint8Array): boolean;
-export declare function encodeI256(i256: bigint): Uint8Array;
-export declare function encodeU256(u256: bigint): Uint8Array;
 export declare function encodeByteVec(hex: string): Uint8Array;
 export declare function encodeAddress(address: string): Uint8Array;
 export declare enum VmValType {

package/dist/src/contract/ralph.js

@@ -16,155 +16,18 @@ 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/>.
 */
-var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildDebugBytecode = exports.encodeContractField = exports.buildContractByteCode = exports.encodeContractFields = exports.buildScriptByteCode = exports.flattenFields = exports.typeLength = exports.encodeMapKey = exports.decodePrimitive = exports.tryDecodeMapDebugLog = exports.calcFieldSize = exports.encodeMapPrefix = exports.parseMapType = exports.splitFields = exports.encodeScriptField = exports.encodeScriptFieldAsString = exports.encodePrimitiveValues = exports.addressVal = exports.byteVecVal = exports.u256Val = exports.i256Val = exports.boolVal = exports.encodeVmAddress = exports.encodeVmByteVec = exports.encodeVmU256 = exports.encodeVmI256 = exports.encodeVmBool = exports.VmValType = exports.encodeAddress = exports.encodeByteVec = exports.encodeU256 = exports.encodeI256 = exports.decodeBool = exports.encodeBool = void 0;
+exports.buildDebugBytecode = exports.encodeContractField = exports.buildContractByteCode = exports.encodeContractFields = exports.buildScriptByteCode = exports.flattenFields = exports.typeLength = exports.encodeMapKey = exports.decodePrimitive = exports.tryDecodeMapDebugLog = exports.calcFieldSize = exports.encodeMapPrefix = exports.parseMapType = exports.splitFields = exports.encodeScriptField = exports.encodeScriptFieldAsString = exports.encodePrimitiveValues = exports.addressVal = exports.byteVecVal = exports.u256Val = exports.i256Val = exports.boolVal = exports.encodeVmAddress = exports.encodeVmByteVec = exports.encodeVmU256 = exports.encodeVmI256 = exports.encodeVmBool = exports.VmValType = exports.encodeAddress = exports.encodeByteVec = void 0;
 const api_1 = require("../api");
 const utils_1 = require("../utils");
 const codec_1 = require("../codec");
-const bigIntZero = BigInt(0);
-class UnSigned {
-}
-UnSigned.oneByteBound = BigInt(0x40);
-UnSigned.twoByteBound = UnSigned.oneByteBound << BigInt(8);
-UnSigned.fourByteBound = UnSigned.oneByteBound << BigInt(8 * 3);
-UnSigned.u256UpperBound = BigInt(1) << BigInt(256);
-class Signed {
-}
-_a = Signed;
-Signed.oneByteBound = BigInt(0x20);
-Signed.twoByteBound = Signed.oneByteBound << BigInt(8);
-Signed.fourByteBound = Signed.oneByteBound << BigInt(8 * 3);
-Signed.i256UpperBound = BigInt(1) << BigInt(255);
-Signed.i256LowerBound = -_a.i256UpperBound;
-class CompactInt {
-}
-CompactInt.oneBytePrefix = 0x00;
-CompactInt.oneByteNegPrefix = 0xc0;
-CompactInt.twoBytePrefix = 0x40;
-CompactInt.twoByteNegPrefix = 0x80;
-CompactInt.fourBytePrefix = 0x80;
-CompactInt.fourByteNegPrefix = 0x40;
-CompactInt.multiBytePrefix = 0xc0;
-function encodeBool(bool) {
-    return bool ? Uint8Array.from([1]) : Uint8Array.from([0]);
-}
-exports.encodeBool = encodeBool;
-function decodeBool(bytes) {
-    if (bytes.length !== 1) {
-        throw new Error(`Expected one byte for encoded bool, got ${bytes.length}`);
-    }
-    return bytes[0] === 1 ? true : false;
-}
-exports.decodeBool = decodeBool;
-function encodeI256(i256) {
-    if (i256 >= bigIntZero) {
-        return encodeI256Positive(i256);
-    }
-    else {
-        return encodeI256Negative(i256);
-    }
-}
-exports.encodeI256 = encodeI256;
-// n should be positive
-function toByteArray(n, signed, notBit) {
-    let hex = n.toString(16);
-    if (hex.length % 2 === 1) {
-        hex = '0' + hex;
-    }
-    else if (signed && hex[0] >= '8') {
-        hex = '00' + hex; // add the byte for sign
-    }
-    const byteLength = hex.length / 2;
-    const bytes = new Uint8Array(byteLength + 1);
-    for (let index = 0; index < byteLength; index++) {
-        const offset = index * 2;
-        const byte = parseInt(hex.slice(offset, offset + 2), 16);
-        bytes[`${index + 1}`] = notBit ? ~byte : byte;
-    }
-    const header = byteLength - 4 + CompactInt.multiBytePrefix;
-    bytes[0] = header;
-    return bytes;
-}
-function encodeI256Positive(i256) {
-    if (i256 < Signed.oneByteBound) {
-        return new Uint8Array([Number(i256) + CompactInt.oneBytePrefix]);
-    }
-    else if (i256 < Signed.twoByteBound) {
-        const num = Number(i256);
-        return new Uint8Array([(num >> 8) + CompactInt.twoBytePrefix, num & 0xff]);
-    }
-    else if (i256 < Signed.fourByteBound) {
-        const num = Number(i256);
-        return new Uint8Array([(num >> 24) + CompactInt.fourBytePrefix, (num >> 16) & 0xff, (num >> 8) & 0xff, num & 0xff]);
-    }
-    else if (i256 < Signed.i256UpperBound) {
-        return toByteArray(i256, true, false);
-    }
-    else {
-        throw Error(`Too large number for i256: ${i256}`);
-    }
-}
-function encodeI256Negative(i256) {
-    if (i256 >= -Signed.oneByteBound) {
-        const num = Number(i256);
-        return new Uint8Array([(num ^ CompactInt.oneByteNegPrefix) & 0xff]);
-    }
-    else if (i256 >= -Signed.twoByteBound) {
-        const num = Number(i256);
-        return new Uint8Array([((num >> 8) ^ CompactInt.twoByteNegPrefix) & 0xff, num & 0xff]);
-    }
-    else if (i256 >= -Signed.fourByteBound) {
-        const num = Number(i256);
-        return new Uint8Array([
-            ((num >> 24) ^ CompactInt.fourByteNegPrefix) & 0xff,
-            (num >> 16) & 0xff,
-            (num >> 8) & 0xff,
-            num & 0xff
-        ]);
-    }
-    else if (i256 >= Signed.i256LowerBound) {
-        return toByteArray(~i256, true, true);
-    }
-    else {
-        throw Error(`Too small number for i256: ${i256}`);
-    }
-}
-function encodeU256(u256) {
-    if (u256 < bigIntZero) {
-        throw Error(`Negative number for U256: ${u256}`);
-    }
-    else if (u256 < UnSigned.oneByteBound) {
-        return new Uint8Array([Number(u256) + CompactInt.oneBytePrefix]);
-    }
-    else if (u256 < UnSigned.twoByteBound) {
-        const num = Number(u256);
-        return new Uint8Array([((num >> 8) & 0xff) + CompactInt.twoBytePrefix, num & 0xff]);
-    }
-    else if (u256 < UnSigned.fourByteBound) {
-        const num = Number(u256);
-        return new Uint8Array([
-            ((num >> 24) & 0xff) + CompactInt.fourBytePrefix,
-            (num >> 16) & 0xff,
-            (num >> 8) & 0xff,
-            num & 0xff
-        ]);
-    }
-    else if (u256 < UnSigned.u256UpperBound) {
-        return toByteArray(u256, false, false);
-    }
-    else {
-        throw Error(`Too large number for U256: ${u256}`);
-    }
-}
-exports.encodeU256 = encodeU256;
+const codec_2 = require("../codec/codec");
 function encodeByteVec(hex) {
     if (!(0, utils_1.isHexString)(hex)) {
         throw Error(`Given value ${hex} is not a valid hex string`);
     }
-    const bytes0 = (0, utils_1.hexToBinUnsafe)(hex);
-    const bytes1 = encodeI256(BigInt(bytes0.length));
-    return (0, utils_1.concatBytes)([bytes1, bytes0]);
+    const bytes = (0, utils_1.hexToBinUnsafe)(hex);
+    return codec_1.byteStringCodec.encode(bytes);
 }
 exports.encodeByteVec = encodeByteVec;
 function encodeAddress(address) {
@@ -180,15 +43,15 @@ var VmValType;
     VmValType[VmValType["Address"] = 4] = "Address";
 })(VmValType = exports.VmValType || (exports.VmValType = {}));
 function encodeVmBool(bool) {
-    return new Uint8Array([VmValType.Bool, ...encodeBool(bool)]);
+    return new Uint8Array([VmValType.Bool, ...codec_2.boolCodec.encode(bool)]);
 }
 exports.encodeVmBool = encodeVmBool;
 function encodeVmI256(i256) {
-    return new Uint8Array([VmValType.I256, ...encodeI256(i256)]);
+    return new Uint8Array([VmValType.I256, ...codec_1.i256Codec.encode(i256)]);
 }
 exports.encodeVmI256 = encodeVmI256;
 function encodeVmU256(u256) {
-    return new Uint8Array([VmValType.U256, ...encodeU256(u256)]);
+    return new Uint8Array([VmValType.U256, ...codec_1.u256Codec.encode(u256)]);
 }
 exports.encodeVmU256 = encodeVmU256;
 function encodeVmByteVec(bytes) {
@@ -226,35 +89,43 @@ exports.encodePrimitiveValues = encodePrimitiveValues;
 function invalidScriptField(tpe, value) {
     return Error(`Invalid script field ${value} for type ${tpe}`);
 }
-var Instruction;
-(function (Instruction) {
-    Instruction[Instruction["trueConst"] = 3] = "trueConst";
-    Instruction[Instruction["falseConst"] = 4] = "falseConst";
-    Instruction[Instruction["i256Const0"] = 5] = "i256Const0";
-    Instruction[Instruction["i256Const1"] = 6] = "i256Const1";
-    Instruction[Instruction["i256Const2"] = 7] = "i256Const2";
-    Instruction[Instruction["i256Const3"] = 8] = "i256Const3";
-    Instruction[Instruction["i256Const4"] = 9] = "i256Const4";
-    Instruction[Instruction["i256Const5"] = 10] = "i256Const5";
-    Instruction[Instruction["i256ConstN1"] = 11] = "i256ConstN1";
-    Instruction[Instruction["u256Const0"] = 12] = "u256Const0";
-    Instruction[Instruction["u256Const1"] = 13] = "u256Const1";
-    Instruction[Instruction["u256Const2"] = 14] = "u256Const2";
-    Instruction[Instruction["u256Const3"] = 15] = "u256Const3";
-    Instruction[Instruction["u256Const4"] = 16] = "u256Const4";
-    Instruction[Instruction["u256Const5"] = 17] = "u256Const5";
-    Instruction[Instruction["i256Const"] = 18] = "i256Const";
-    Instruction[Instruction["u256Const"] = 19] = "u256Const";
-    Instruction[Instruction["bytesConst"] = 20] = "bytesConst";
-    Instruction[Instruction["addressConst"] = 21] = "addressConst";
-})(Instruction || (Instruction = {}));
-// TODO: optimize
 function encodeScriptFieldI256(value) {
-    return new Uint8Array([Instruction.i256Const, ...encodeI256(value)]);
+    switch (value) {
+        case 0n:
+            return codec_1.instrCodec.encode(codec_1.I256Const0);
+        case 1n:
+            return codec_1.instrCodec.encode(codec_1.I256Const1);
+        case 2n:
+            return codec_1.instrCodec.encode(codec_1.I256Const2);
+        case 3n:
+            return codec_1.instrCodec.encode(codec_1.I256Const3);
+        case 4n:
+            return codec_1.instrCodec.encode(codec_1.I256Const4);
+        case 5n:
+            return codec_1.instrCodec.encode(codec_1.I256Const5);
+        case -1n:
+            return codec_1.instrCodec.encode(codec_1.I256ConstN1);
+        default:
+            return codec_1.instrCodec.encode((0, codec_1.I256Const)(value));
+    }
 }
-// TODO: optimize
 function encodeScriptFieldU256(value) {
-    return new Uint8Array([Instruction.u256Const, ...encodeU256(value)]);
+    switch (value) {
+        case 0n:
+            return codec_1.instrCodec.encode(codec_1.U256Const0);
+        case 1n:
+            return codec_1.instrCodec.encode(codec_1.U256Const1);
+        case 2n:
+            return codec_1.instrCodec.encode(codec_1.U256Const2);
+        case 3n:
+            return codec_1.instrCodec.encode(codec_1.U256Const3);
+        case 4n:
+            return codec_1.instrCodec.encode(codec_1.U256Const4);
+        case 5n:
+            return codec_1.instrCodec.encode(codec_1.U256Const5);
+        default:
+            return codec_1.instrCodec.encode((0, codec_1.U256Const)(value));
+    }
 }
 function encodeScriptFieldAsString(tpe, value) {
     return (0, utils_1.binToHex)(encodeScriptField(tpe, value));
@@ -263,7 +134,7 @@ exports.encodeScriptFieldAsString = encodeScriptFieldAsString;
 function encodeScriptField(tpe, value) {
     switch (tpe) {
         case 'Bool':
-            const byte = (0, api_1.toApiBoolean)(value) ? Instruction.trueConst : Instruction.falseConst;
+            const byte = (0, api_1.toApiBoolean)(value) ? codec_1.ConstTrue.code : codec_1.ConstFalse.code;
             return new Uint8Array([byte]);
         case 'I256':
             const i256 = (0, api_1.toApiNumber256)(value);
@@ -273,10 +144,10 @@ function encodeScriptField(tpe, value) {
             return encodeScriptFieldU256(BigInt(u256));
         case 'Address':
             const address = (0, api_1.toApiAddress)(value);
-            return new Uint8Array([Instruction.addressConst, ...encodeAddress(address)]);
+            return new Uint8Array([codec_1.AddressConstCode, ...encodeAddress(address)]);
         default: // ByteVec or Contract
             const hexStr = (0, api_1.toApiByteVec)(value);
-            return new Uint8Array([Instruction.bytesConst, ...encodeByteVec(hexStr)]);
+            return new Uint8Array([codec_1.BytesConstCode, ...encodeByteVec(hexStr)]);
     }
     throw invalidScriptField(tpe, value);
 }
@@ -366,11 +237,11 @@ exports.tryDecodeMapDebugLog = tryDecodeMapDebugLog;
 function decodePrimitive(value, type) {
     switch (type) {
         case 'Bool':
-            return decodeBool(value);
+            return codec_2.boolCodec.decode(value);
         case 'I256':
-            return codec_1.compactSignedIntCodec.decodeI256(value);
+            return codec_1.i256Codec.decode(value);
         case 'U256':
-            return codec_1.compactUnsignedIntCodec.decodeU256(value);
+            return codec_1.u256Codec.decode(value);
         case 'ByteVec':
             return (0, utils_1.binToHex)(value);
         case 'Address':
@@ -387,10 +258,10 @@ function encodeMapKey(value, type) {
             return new Uint8Array([byte]);
         case 'I256':
             const i256 = (0, api_1.toApiNumber256)(value);
-            return encodeI256(BigInt(i256));
+            return codec_1.i256Codec.encode(BigInt(i256));
         case 'U256':
             const u256 = (0, api_1.toApiNumber256)(value);
-            return encodeU256(BigInt(u256));
+            return codec_1.u256Codec.encode(BigInt(u256));
         case 'ByteVec':
             const hexStr = (0, api_1.toApiByteVec)(value);
             return (0, utils_1.hexToBinUnsafe)(hexStr);
@@ -493,7 +364,7 @@ function _encodeField(fieldName, encodeFunc) {
     }
 }
 function encodeFields(fields) {
-    const prefix = encodeI256(BigInt(fields.length));
+    const prefix = codec_1.i32Codec.encode(fields.length);
     return fields.reduce((acc, field) => {
         const encoded = _encodeField(field.name, () => encodeContractField(field.type, field.value));
         const bytes = new Uint8Array(acc.byteLength + encoded.byteLength);

package/dist/src/contract/script-simulator.d.ts

@@ -0,0 +1,27 @@
+import { Token } from '../api';
+import { Method } from '../codec';
+import { Script } from '../codec/script-codec';
+import { HexString } from '../utils';
+/**
+ * Contract call extracted from a script
+ * @param contractAddress the address of the contract
+ * @param approvedAttoAlphAmount the amount of ALPH approved to the contract
+ *   - undefined if no ALPH is approved
+ *   - 'unknown' if the amount cannot be determined
+ *   - a number if the amount is known
+ * @param approvedTokens the tokens approved to the contract
+ *  - undefined if no tokens are approved
+ *  - 'unknown' if the tokens cannot be determined
+ *  - an array of tokens if the tokens are known
+ */
+export interface ContractCall {
+    contractAddress: string;
+    approvedAttoAlphAmount?: bigint | 'unknown';
+    approvedTokens?: Token[] | 'unknown';
+}
+export declare class ScriptSimulator {
+    static extractContractCalls(unsignedTx: HexString): ContractCall[];
+    static extractContractCallsWithErrors(unsignedTx: HexString): ContractCall[];
+    static extractContractCallsFromScript(script: Script): ContractCall[];
+    static extractContractCallsFromMainMethod(mainMethod: Method): ContractCall[];
+}