@alephium/web3 2.0.10 → 3.0.0-test.1

package/dist/_esm/contract/contract.js

@@ -0,0 +1,1449 @@
+import { fromApiNumber256, toApiNumber256, toApiToken, toApiVal, fromApiTokens, getDefaultPrimitiveValue, PrimitiveTypes, decodeArrayType, fromApiPrimitiveVal, tryGetCallResult, decodeTupleType, stringify } from '../api';
+import * as ralph from './ralph';
+import { bs58, binToHex, assertType, WebCrypto, hexToBinUnsafe, isDevnet, isHexString, hexToString } from '../utils';
+import { contractIdFromAddress, groupOfAddress, addressFromContractId, subContractId, isGrouplessAddress, isValidAddress, addressWithoutExplicitGroupIndex } from '../address';
+import { getCurrentNodeProvider } from '../global';
+import { subscribeToEvents } from './events';
+import { MINIMAL_CONTRACT_DEPOSIT, ONE_ALPH, TOTAL_NUMBER_OF_GROUPS } from '../constants';
+import { blake2b } from '@noble/hashes/blake2b';
+import { isContractDebugMessageEnabled } from '../debug';
+import { contract, LoadLocal, LoadImmFieldByIndex, LoadMutFieldByIndex, CallerContractId, LoadImmField, ByteVecEq, Assert, StoreMutFieldByIndex, DestroySelf, Pop, StoreLocal, instrCodec, U256Const, ApproveToken, ApproveAlph, CallExternal, Dup, CallerAddress, i32Codec, BytesConst } from '../codec';
+import { TraceableError } from '../error';
+const crypto = new WebCrypto();
+export const StdIdFieldName = '__stdInterfaceId';
+export const DEFAULT_NODE_COMPILER_OPTIONS = {
+    ignoreUnusedConstantsWarnings: false,
+    ignoreUnusedVariablesWarnings: false,
+    ignoreUnusedFieldsWarnings: false,
+    ignoreUnusedPrivateFunctionsWarnings: false,
+    ignoreUpdateFieldsCheckWarnings: false,
+    ignoreCheckExternalCallerWarnings: false,
+    ignoreUnusedFunctionReturnWarnings: false,
+    skipAbstractContractCheck: false,
+    skipTests: false
+};
+export const DEFAULT_COMPILER_OPTIONS = { errorOnWarnings: true, ...DEFAULT_NODE_COMPILER_OPTIONS };
+export class Struct {
+    constructor(name, fieldNames, fieldTypes, isMutable) {
+        this.name = name;
+        this.fieldNames = fieldNames;
+        this.fieldTypes = fieldTypes;
+        this.isMutable = isMutable;
+    }
+    static fromJson(json) {
+        if (json.name === null || json.fieldNames === null || json.fieldTypes === null || json.isMutable === null) {
+            throw Error('The JSON for struct is incomplete');
+        }
+        return new Struct(json.name, json.fieldNames, json.fieldTypes, json.isMutable);
+    }
+    static fromStructSig(sig) {
+        return new Struct(sig.name, sig.fieldNames, sig.fieldTypes, sig.isMutable);
+    }
+    toJson() {
+        return {
+            name: this.name,
+            fieldNames: this.fieldNames,
+            fieldTypes: this.fieldTypes,
+            isMutable: this.isMutable
+        };
+    }
+}
+export class Artifact {
+    constructor(version, name, functions) {
+        this.version = version;
+        this.name = name;
+        this.functions = functions;
+    }
+    async isDevnet(signer) {
+        if (!signer.nodeProvider) {
+            return false;
+        }
+        const chainParams = await signer.nodeProvider.infos.getInfosChainParams();
+        return isDevnet(chainParams.networkId);
+    }
+}
+function fromFunctionSig(sig) {
+    return {
+        name: sig.name,
+        paramNames: sig.paramNames,
+        paramTypes: sig.paramTypes,
+        paramIsMutable: sig.paramIsMutable,
+        returnTypes: sig.returnTypes
+    };
+}
+export class Contract extends Artifact {
+    constructor(version, name, bytecode, bytecodeDebugPatch, codeHash, codeHashDebug, fieldsSig, eventsSig, functions, constants, enums, structs, mapsSig, stdInterfaceId) {
+        super(version, name, functions);
+        this.bytecode = bytecode;
+        this.bytecodeDebugPatch = bytecodeDebugPatch;
+        this.codeHash = codeHash;
+        this.fieldsSig = fieldsSig;
+        this.eventsSig = eventsSig;
+        this.constants = constants;
+        this.enums = enums;
+        this.structs = structs;
+        this.mapsSig = mapsSig;
+        this.stdInterfaceId = stdInterfaceId;
+        this.bytecodeDebug = ralph.buildDebugBytecode(this.bytecode, this.bytecodeDebugPatch);
+        this.codeHashDebug = codeHashDebug;
+        this.decodedContract = contract.contractCodec.decodeContract(hexToBinUnsafe(this.bytecode));
+        this.bytecodeForTesting = undefined;
+        this.decodedTestingContract = undefined;
+        this.codeHashForTesting = undefined;
+    }
+    isInlineFunc(index) {
+        if (index >= this.functions.length) {
+            throw new Error(`Invalid function index ${index}, function size: ${this.functions.length}`);
+        }
+        const inlineFuncFromIndex = this.decodedContract.methods.length;
+        return index >= inlineFuncFromIndex;
+    }
+    getByteCodeForTesting() {
+        if (this.bytecodeForTesting !== undefined)
+            return this.bytecodeForTesting;
+        const hasInlineFunction = this.functions.length > this.decodedContract.methods.length;
+        if (!hasInlineFunction && this.publicFunctions().length == this.functions.length) {
+            this.bytecodeForTesting = this.bytecodeDebug;
+            this.codeHashForTesting = this.codeHashDebug;
+            return this.bytecodeForTesting;
+        }
+        const decodedDebugContract = contract.contractCodec.decodeContract(hexToBinUnsafe(this.bytecodeDebug));
+        const methods = decodedDebugContract.methods.map((method) => ({ ...method, isPublic: true }));
+        const bytecodeForTesting = contract.contractCodec.encodeContract({
+            fieldLength: decodedDebugContract.fieldLength,
+            methods: methods
+        });
+        const codeHashForTesting = blake2b(bytecodeForTesting, { dkLen: 32 });
+        this.bytecodeForTesting = binToHex(bytecodeForTesting);
+        this.codeHashForTesting = binToHex(codeHashForTesting);
+        return this.bytecodeForTesting;
+    }
+    getDecodedTestingContract() {
+        if (this.decodedTestingContract !== undefined)
+            return this.decodedTestingContract;
+        const bytecodeForTesting = hexToBinUnsafe(this.getByteCodeForTesting());
+        this.decodedTestingContract = contract.contractCodec.decodeContract(bytecodeForTesting);
+        return this.decodedTestingContract;
+    }
+    hasCodeHash(hash) {
+        return this.codeHash === hash || this.codeHashDebug === hash || this.codeHashForTesting === hash;
+    }
+    getDecodedMethod(methodIndex) {
+        return this.decodedContract.methods[`${methodIndex}`];
+    }
+    publicFunctions() {
+        return this.functions.filter((_, index) => this.getDecodedMethod(index).isPublic);
+    }
+    usingPreapprovedAssetsFunctions() {
+        return this.functions.filter((_, index) => this.getDecodedMethod(index).usePreapprovedAssets);
+    }
+    usingAssetsInContractFunctions() {
+        return this.functions.filter((_, index) => this.getDecodedMethod(index).useContractAssets);
+    }
+    isMethodUsePreapprovedAssets(isDevnet, methodIndex) {
+        if (!isDevnet || !this.isInlineFunc(methodIndex))
+            return this.getDecodedMethod(methodIndex).usePreapprovedAssets;
+        const contract = this.getDecodedTestingContract();
+        return contract.methods[`${methodIndex}`].usePreapprovedAssets;
+    }
+    static fromJson(artifact, bytecodeDebugPatch = '', codeHashDebug = '', structs = []) {
+        if (artifact.version == null ||
+            artifact.name == null ||
+            artifact.bytecode == null ||
+            artifact.codeHash == null ||
+            artifact.fieldsSig == null ||
+            artifact.eventsSig == null ||
+            artifact.constants == null ||
+            artifact.enums == null ||
+            artifact.functions == null) {
+            throw Error('The artifact JSON for contract is incomplete');
+        }
+        const contract = new Contract(artifact.version, artifact.name, artifact.bytecode, bytecodeDebugPatch, artifact.codeHash, codeHashDebug ? codeHashDebug : artifact.codeHash, artifact.fieldsSig, artifact.eventsSig, artifact.functions, artifact.constants, artifact.enums, structs, artifact.mapsSig === null ? undefined : artifact.mapsSig, artifact.stdInterfaceId === null ? undefined : artifact.stdInterfaceId);
+        return contract;
+    }
+    static fromCompileResult(result, structs = []) {
+        return new Contract(result.version, result.name, result.bytecode, result.bytecodeDebugPatch, result.codeHash, result.codeHashDebug, result.fields, result.events, result.functions.map(fromFunctionSig), result.constants, result.enums, structs, result.maps, result.stdInterfaceId);
+    }
+    static async fromArtifactFile(path, bytecodeDebugPatch, codeHashDebug, structs = []) {
+        const fs = await import('fs');
+        const content = await fs.promises.readFile(path);
+        const artifact = JSON.parse(content.toString());
+        return Contract.fromJson(artifact, bytecodeDebugPatch, codeHashDebug, structs);
+    }
+    toString() {
+        const object = {
+            version: this.version,
+            name: this.name,
+            bytecode: this.bytecode,
+            codeHash: this.codeHash,
+            fieldsSig: this.fieldsSig,
+            eventsSig: this.eventsSig,
+            functions: this.functions,
+            constants: this.constants,
+            enums: this.enums
+        };
+        if (this.mapsSig !== undefined) {
+            object.mapsSig = this.mapsSig;
+        }
+        if (this.stdInterfaceId !== undefined) {
+            object.stdInterfaceId = this.stdInterfaceId;
+        }
+        return stringify(object, null, 2);
+    }
+    getInitialFieldsWithDefaultValues() {
+        const fields = this.stdInterfaceId === undefined
+            ? this.fieldsSig
+            : {
+                names: this.fieldsSig.names.slice(0, -1),
+                types: this.fieldsSig.types.slice(0, -1),
+                isMutable: this.fieldsSig.isMutable.slice(0, -1)
+            };
+        return getDefaultValue(fields, this.structs);
+    }
+    toState(fields, asset, address) {
+        const addressDef = typeof address !== 'undefined' ? address : Contract.randomAddress();
+        return {
+            address: addressDef,
+            contractId: binToHex(contractIdFromAddress(addressDef)),
+            bytecode: this.bytecode,
+            codeHash: this.codeHash,
+            fields: fields,
+            fieldsSig: this.fieldsSig,
+            asset: asset
+        };
+    }
+    static randomAddress() {
+        const bytes = new Uint8Array(33);
+        crypto.getRandomValues(bytes);
+        bytes[0] = 3;
+        return bs58.encode(bytes);
+    }
+    printDebugMessages(funcName, messages) {
+        if (isContractDebugMessageEnabled() && messages.length != 0) {
+            console.log(`Testing ${this.name}.${funcName}:`);
+            messages.forEach((m) => printDebugMessage(m));
+        }
+    }
+    toApiFields(fields) {
+        if (typeof fields === 'undefined') {
+            return [];
+        }
+        else {
+            return toApiFields(fields, this.fieldsSig, this.structs);
+        }
+    }
+    toApiArgs(funcName, args) {
+        if (args) {
+            const func = this.functions.find((func) => func.name == funcName);
+            if (func == null) {
+                throw new Error(`Invalid function name: ${funcName}`);
+            }
+            return toApiArgs(args, func, this.structs);
+        }
+        else {
+            return [];
+        }
+    }
+    getMethodIndex(funcName) {
+        return this.functions.findIndex((func) => func.name === funcName);
+    }
+    toApiContractStates(states) {
+        return typeof states != 'undefined' ? states.map((state) => toApiContractState(state, this.structs)) : undefined;
+    }
+    toApiTestContractParams(funcName, params) {
+        const allFields = params.initialFields === undefined
+            ? []
+            : ralph.flattenFields(params.initialFields, this.fieldsSig.names, this.fieldsSig.types, this.fieldsSig.isMutable, this.structs);
+        const immFields = allFields.filter((f) => !f.isMutable).map((f) => toApiVal(f.value, f.type));
+        const mutFields = allFields.filter((f) => f.isMutable).map((f) => toApiVal(f.value, f.type));
+        const methodIndex = this.getMethodIndex(funcName);
+        return {
+            group: params.group,
+            blockHash: params.blockHash,
+            blockTimeStamp: params.blockTimeStamp,
+            txId: params.txId,
+            address: params.contractAddress,
+            callerContractAddress: params.callerContractAddress,
+            bytecode: this.isInlineFunc(methodIndex) ? this.getByteCodeForTesting() : this.bytecodeDebug,
+            initialImmFields: immFields,
+            initialMutFields: mutFields,
+            initialAsset: typeof params.initialAsset !== 'undefined' ? toApiAsset(params.initialAsset) : undefined,
+            methodIndex,
+            args: this.toApiArgs(funcName, params.args),
+            existingContracts: this.toApiContractStates(params.existingContracts),
+            inputAssets: toApiInputAssets(params.inputAssets),
+            dustAmount: params.dustAmount?.toString()
+        };
+    }
+    fromApiContractState(state) {
+        return {
+            address: state.address,
+            contractId: binToHex(contractIdFromAddress(state.address)),
+            bytecode: state.bytecode,
+            initialStateHash: state.initialStateHash,
+            codeHash: state.codeHash,
+            fields: fromApiFields(state.immFields, state.mutFields, this.fieldsSig, this.structs),
+            fieldsSig: this.fieldsSig,
+            asset: fromApiAsset(state.asset)
+        };
+    }
+    static fromApiContractState(state, getContractByCodeHash) {
+        const contract = getContractByCodeHash(state.codeHash);
+        return contract.fromApiContractState(state);
+    }
+    static fromApiEvent(event, codeHash, txId, getContractByCodeHash) {
+        let fields;
+        let name;
+        if (event.eventIndex == Contract.ContractCreatedEventIndex) {
+            fields = toContractCreatedEventFields(fromApiEventFields(event.fields, Contract.ContractCreatedEvent, true));
+            name = Contract.ContractCreatedEvent.name;
+        }
+        else if (event.eventIndex == Contract.ContractDestroyedEventIndex) {
+            fields = fromApiEventFields(event.fields, Contract.ContractDestroyedEvent, true);
+            name = Contract.ContractDestroyedEvent.name;
+        }
+        else {
+            const contract = getContractByCodeHash(codeHash);
+            const eventSig = contract.eventsSig[event.eventIndex];
+            fields = fromApiEventFields(event.fields, eventSig);
+            name = eventSig.name;
+        }
+        return {
+            txId: txId,
+            blockHash: event.blockHash,
+            contractAddress: event.contractAddress,
+            name: name,
+            eventIndex: event.eventIndex,
+            fields: fields
+        };
+    }
+    fromApiTestContractResult(methodName, result, txId, getContractByCodeHash) {
+        const methodIndex = this.functions.findIndex((sig) => sig.name === methodName);
+        const returnTypes = this.functions[`${methodIndex}`].returnTypes;
+        const rawReturn = fromApiArray(result.returns, returnTypes, this.structs);
+        const returns = rawReturn.length === 0 ? null : rawReturn.length === 1 ? rawReturn[0] : rawReturn;
+        const addressToCodeHash = new Map();
+        addressToCodeHash.set(result.address, result.codeHash);
+        result.contracts.forEach((contract) => addressToCodeHash.set(contract.address, contract.codeHash));
+        return {
+            contractId: binToHex(contractIdFromAddress(result.address)),
+            contractAddress: result.address,
+            returns: returns,
+            gasUsed: result.gasUsed,
+            contracts: result.contracts.map((contract) => Contract.fromApiContractState(contract, getContractByCodeHash)),
+            txOutputs: result.txOutputs.map(fromApiOutput),
+            events: Contract.fromApiEvents(result.events, addressToCodeHash, txId, getContractByCodeHash),
+            debugMessages: result.debugMessages
+        };
+    }
+    async txParamsForDeployment(signer, params, group) {
+        const isDevnet = await this.isDevnet(signer);
+        const initialFields = params.initialFields ?? {};
+        const bytecode = this.buildByteCodeToDeploy(addStdIdToFields(this, initialFields), isDevnet, params.exposePrivateFunctions ?? false);
+        const selectedAccount = await signer.getSelectedAccount();
+        if (selectedAccount.keyType === 'gl-secp256k1') {
+            if (group === undefined) {
+                throw new Error('Groupless address requires explicit group number for contract deployment');
+            }
+        }
+        const signerParams = {
+            signerAddress: selectedAccount.address,
+            signerKeyType: selectedAccount.keyType,
+            bytecode: bytecode,
+            initialAttoAlphAmount: params?.initialAttoAlphAmount,
+            issueTokenAmount: params?.issueTokenAmount,
+            issueTokenTo: params?.issueTokenTo,
+            initialTokenAmounts: params?.initialTokenAmounts,
+            gasAmount: params?.gasAmount,
+            gasPrice: params?.gasPrice,
+            group: group
+        };
+        return signerParams;
+    }
+    buildByteCodeToDeploy(initialFields, isDevnet, exposePrivateFunctions = false) {
+        if (exposePrivateFunctions && !isDevnet) {
+            throw new Error('Cannot expose private functions in non-devnet environment');
+        }
+        try {
+            const bytecode = exposePrivateFunctions && isDevnet
+                ? this.getByteCodeForTesting()
+                : isDevnet
+                    ? this.bytecodeDebug
+                    : this.bytecode;
+            return ralph.buildContractByteCode(bytecode, initialFields, this.fieldsSig, this.structs);
+        }
+        catch (error) {
+            throw new TraceableError(`Failed to build bytecode for contract ${this.name}`, error);
+        }
+    }
+    static fromApiEvents(events, addressToCodeHash, txId, getContractByCodeHash) {
+        return events.map((event) => {
+            const contractAddress = event.contractAddress;
+            const codeHash = addressToCodeHash.get(contractAddress);
+            if (typeof codeHash !== 'undefined' || event.eventIndex < 0) {
+                return Contract.fromApiEvent(event, codeHash, txId, getContractByCodeHash);
+            }
+            else {
+                throw Error(`Cannot find codeHash for the contract address: ${contractAddress}`);
+            }
+        });
+    }
+    toApiCallContract(params, groupIndex, contractAddress, methodIndex) {
+        const functionSig = this.functions[`${methodIndex}`];
+        const args = toApiArgs(params.args ?? {}, functionSig, this.structs);
+        return {
+            ...params,
+            group: groupIndex,
+            address: contractAddress,
+            methodIndex: methodIndex,
+            args: args,
+            inputAssets: toApiInputAssets(params.inputAssets)
+        };
+    }
+    fromApiCallContractResult(result, txId, methodIndex, getContractByCodeHash) {
+        const returnTypes = this.functions[`${methodIndex}`].returnTypes;
+        const callResult = tryGetCallResult(result);
+        return fromCallResult(callResult, txId, returnTypes, this.structs, getContractByCodeHash);
+    }
+}
+Contract.ContractCreatedEventIndex = -1;
+Contract.ContractCreatedEvent = {
+    name: 'ContractCreated',
+    fieldNames: ['address', 'parentAddress', 'stdInterfaceId'],
+    fieldTypes: ['Address', 'Address', 'ByteVec']
+};
+Contract.ContractDestroyedEventIndex = -2;
+Contract.ContractDestroyedEvent = {
+    name: 'ContractDestroyed',
+    fieldNames: ['address'],
+    fieldTypes: ['Address']
+};
+Contract.DebugEventIndex = -3;
+function fromCallResult(callResult, txId, returnTypes, structs, getContractByCodeHash) {
+    const rawReturn = fromApiArray(callResult.returns, returnTypes, structs);
+    const returns = rawReturn.length === 0 ? null : rawReturn.length === 1 ? rawReturn[0] : rawReturn;
+    const addressToCodeHash = new Map();
+    callResult.contracts.forEach((contract) => addressToCodeHash.set(contract.address, contract.codeHash));
+    return {
+        returns: returns,
+        gasUsed: callResult.gasUsed,
+        contracts: callResult.contracts.map((state) => Contract.fromApiContractState(state, getContractByCodeHash)),
+        txInputs: callResult.txInputs,
+        txOutputs: callResult.txOutputs.map((output) => fromApiOutput(output)),
+        events: Contract.fromApiEvents(callResult.events, addressToCodeHash, txId, getContractByCodeHash),
+        debugMessages: callResult.debugMessages
+    };
+}
+export class Script extends Artifact {
+    constructor(version, name, bytecodeTemplate, bytecodeDebugPatch, fieldsSig, functions, structs) {
+        super(version, name, functions);
+        this.bytecodeTemplate = bytecodeTemplate;
+        this.bytecodeDebugPatch = bytecodeDebugPatch;
+        this.fieldsSig = fieldsSig;
+        this.structs = structs;
+    }
+    static fromCompileResult(result, structs = []) {
+        return new Script(result.version, result.name, result.bytecodeTemplate, result.bytecodeDebugPatch, result.fields, result.functions.map(fromFunctionSig), structs);
+    }
+    static fromJson(artifact, bytecodeDebugPatch = '', structs = []) {
+        if (artifact.version == null ||
+            artifact.name == null ||
+            artifact.bytecodeTemplate == null ||
+            artifact.fieldsSig == null ||
+            artifact.functions == null) {
+            throw Error('The artifact JSON for script is incomplete');
+        }
+        return new Script(artifact.version, artifact.name, artifact.bytecodeTemplate, bytecodeDebugPatch, artifact.fieldsSig, artifact.functions, structs);
+    }
+    static async fromArtifactFile(path, bytecodeDebugPatch, structs = []) {
+        const fs = await import('fs');
+        const content = await fs.promises.readFile(path);
+        const artifact = JSON.parse(content.toString());
+        return this.fromJson(artifact, bytecodeDebugPatch, structs);
+    }
+    toString() {
+        const object = {
+            version: this.version,
+            name: this.name,
+            bytecodeTemplate: this.bytecodeTemplate,
+            fieldsSig: this.fieldsSig,
+            functions: this.functions
+        };
+        return stringify(object, null, 2);
+    }
+    async txParamsForExecution(params) {
+        const selectedAccount = await params.signer.getSelectedAccount();
+        const bytecode = this.buildByteCodeToDeploy(params.initialFields ?? {});
+        const signerParams = {
+            signerAddress: selectedAccount.address,
+            signerKeyType: selectedAccount.keyType,
+            bytecode,
+            attoAlphAmount: params.attoAlphAmount,
+            tokens: params.tokens,
+            gasAmount: params.gasAmount,
+            gasPrice: params.gasPrice,
+            dustAmount: params.dustAmount
+        };
+        return signerParams;
+    }
+    buildByteCodeToDeploy(initialFields) {
+        try {
+            return ralph.buildScriptByteCode(this.bytecodeTemplate, initialFields, this.fieldsSig, this.structs);
+        }
+        catch (error) {
+            throw new TraceableError(`Failed to build bytecode for script ${this.name}`, error);
+        }
+    }
+}
+export function fromApiFields(immFields, mutFields, fieldsSig, structs) {
+    let [immIndex, mutIndex] = [0, 0];
+    const func = (type, isMutable) => {
+        const nodeVal = isMutable ? mutFields[mutIndex++] : immFields[immIndex++];
+        return fromApiPrimitiveVal(nodeVal, type);
+    };
+    return fieldsSig.names.reduce((acc, name, index) => {
+        const fieldType = fieldsSig.types[`${index}`];
+        const isMutable = fieldsSig.isMutable[`${index}`];
+        acc[`${name}`] = buildVal(isMutable, fieldType, structs, func);
+        return acc;
+    }, {});
+}
+function buildVal(isMutable, type, structs, func) {
+    if (type.startsWith('[')) {
+        const [baseType, size] = decodeArrayType(type);
+        return Array.from(Array(size).keys()).map(() => buildVal(isMutable, baseType, structs, func));
+    }
+    if (type.startsWith('(')) {
+        const tuple = decodeTupleType(type);
+        return tuple.reduce((acc, fieldType) => {
+            acc.push(buildVal(isMutable, fieldType, structs, func));
+            return acc;
+        }, []);
+    }
+    const struct = structs.find((s) => s.name === type);
+    if (struct !== undefined) {
+        return struct.fieldNames.reduce((acc, name, index) => {
+            const fieldType = struct.fieldTypes[`${index}`];
+            const isFieldMutable = isMutable && struct.isMutable[`${index}`];
+            acc[`${name}`] = buildVal(isFieldMutable, fieldType, structs, func);
+            return acc;
+        }, {});
+    }
+    const primitiveType = PrimitiveTypes.includes(type) ? type : 'ByteVec';
+    return func(primitiveType, isMutable);
+}
+export function getDefaultValue(fieldsSig, structs) {
+    return fieldsSig.names.reduce((acc, name, index) => {
+        const type = fieldsSig.types[`${index}`];
+        acc[`${name}`] = buildVal(false, type, structs, getDefaultPrimitiveValue);
+        return acc;
+    }, {});
+}
+function fromApiVal(iter, type, structs, systemEvent = false) {
+    const func = (primitiveType) => {
+        const currentValue = iter.next();
+        if (currentValue.done)
+            throw Error('Not enough vals');
+        return fromApiPrimitiveVal(currentValue.value, primitiveType, systemEvent);
+    };
+    return buildVal(false, type, structs, func);
+}
+export function fromApiArray(values, types, structs) {
+    const iter = values.values();
+    return types.map((type) => fromApiVal(iter, type, structs));
+}
+export function fromApiEventFields(vals, eventSig, systemEvent = false) {
+    const iter = vals.values();
+    return eventSig.fieldNames.reduce((acc, name, index) => {
+        const type = eventSig.fieldTypes[`${index}`];
+        acc[`${name}`] = fromApiVal(iter, type, [], systemEvent);
+        return acc;
+    }, {});
+}
+function toApiAsset(asset) {
+    return {
+        attoAlphAmount: toApiNumber256(asset.alphAmount),
+        tokens: typeof asset.tokens !== 'undefined' ? asset.tokens.map(toApiToken) : []
+    };
+}
+function fromApiAsset(asset) {
+    return {
+        alphAmount: fromApiNumber256(asset.attoAlphAmount),
+        tokens: fromApiTokens(asset.tokens)
+    };
+}
+function toApiContractState(state, structs) {
+    const stateFields = state.fields ?? {};
+    const fieldsSig = state.fieldsSig;
+    const allFields = ralph.flattenFields(stateFields, fieldsSig.names, fieldsSig.types, fieldsSig.isMutable, structs);
+    const immFields = allFields.filter((f) => !f.isMutable).map((f) => toApiVal(f.value, f.type));
+    const mutFields = allFields.filter((f) => f.isMutable).map((f) => toApiVal(f.value, f.type));
+    return {
+        address: state.address,
+        bytecode: state.bytecode,
+        codeHash: state.codeHash,
+        initialStateHash: state.initialStateHash,
+        immFields,
+        mutFields,
+        asset: toApiAsset(state.asset)
+    };
+}
+function toApiFields(fields, fieldsSig, structs) {
+    return ralph
+        .flattenFields(fields, fieldsSig.names, fieldsSig.types, fieldsSig.isMutable, structs)
+        .map((f) => toApiVal(f.value, f.type));
+}
+function toApiArgs(args, funcSig, structs) {
+    return ralph
+        .flattenFields(args, funcSig.paramNames, funcSig.paramTypes, funcSig.paramIsMutable, structs)
+        .map((f) => toApiVal(f.value, f.type));
+}
+function toApiInputAsset(inputAsset) {
+    return { address: inputAsset.address, asset: toApiAsset(inputAsset.asset) };
+}
+function toApiInputAssets(inputAssets) {
+    return typeof inputAssets !== 'undefined' ? inputAssets.map(toApiInputAsset) : undefined;
+}
+function fromApiOutput(output) {
+    if (output.type === 'AssetOutput') {
+        const asset = output;
+        return {
+            type: 'AssetOutput',
+            address: asset.address,
+            alphAmount: fromApiNumber256(asset.attoAlphAmount),
+            tokens: fromApiTokens(asset.tokens),
+            lockTime: asset.lockTime,
+            message: asset.message
+        };
+    }
+    else if (output.type === 'ContractOutput') {
+        const asset = output;
+        return {
+            type: 'ContractOutput',
+            address: asset.address,
+            alphAmount: fromApiNumber256(asset.attoAlphAmount),
+            tokens: fromApiTokens(asset.tokens)
+        };
+    }
+    else {
+        throw new Error(`Unknown output type: ${output}`);
+    }
+}
+export function randomTxId() {
+    const bytes = new Uint8Array(32);
+    crypto.getRandomValues(bytes);
+    return binToHex(bytes);
+}
+assertType;
+export class ContractFactory {
+    constructor(contract) {
+        this.contract = contract;
+    }
+    async deploy(signer, deployParams, group) {
+        const signerParams = await this.contract.txParamsForDeployment(signer, {
+            ...deployParams,
+            initialFields: addStdIdToFields(this.contract, deployParams.initialFields)
+        }, group);
+        const result = await signer.signAndSubmitDeployContractTx(signerParams);
+        if ('transferTxs' in result) {
+            return {
+                ...result,
+                contractInstance: this.at(result.contractAddress)
+            };
+        }
+        else {
+            return {
+                ...result,
+                contractInstance: this.at(result.contractAddress)
+            };
+        }
+    }
+    async deployTemplate(signer) {
+        return this.deploy(signer, {
+            initialFields: this.contract.getInitialFieldsWithDefaultValues()
+        });
+    }
+    stateForTest_(initFields, asset, address, maps) {
+        const newAsset = {
+            alphAmount: asset?.alphAmount ?? MINIMAL_CONTRACT_DEPOSIT,
+            tokens: asset?.tokens
+        };
+        const state = this.contract.toState(addStdIdToFields(this.contract, initFields), newAsset, address);
+        return {
+            ...state,
+            bytecode: this.contract.bytecodeDebug,
+            codeHash: this.contract.codeHash,
+            maps: maps
+        };
+    }
+}
+export class ExecutableScript {
+    constructor(script, getContractByCodeHash) {
+        this.script = script;
+        this.getContractByCodeHash = getContractByCodeHash;
+    }
+    async execute(params) {
+        const signerParams = await this.script.txParamsForExecution(params);
+        return await params.signer.signAndSubmitExecuteScriptTx(signerParams);
+    }
+    async call(params) {
+        const mainFunc = this.script.functions.find((f) => f.name === 'main');
+        if (mainFunc === undefined) {
+            throw new Error(`There is no main function in script ${this.script.name}`);
+        }
+        const bytecode = this.script.buildByteCodeToDeploy(params.initialFields);
+        const txId = params.txId ?? randomTxId();
+        const provider = getCurrentNodeProvider();
+        const callResult = await provider.contracts.postContractsCallTxScript({
+            ...params,
+            group: params.groupIndex ?? 0,
+            bytecode: bytecode,
+            inputAssets: toApiInputAssets(params.inputAssets)
+        });
+        const returnTypes = mainFunc.returnTypes;
+        const result = fromCallResult(callResult, txId, returnTypes, this.script.structs, this.getContractByCodeHash);
+        return result;
+    }
+}
+function specialContractAddress(eventIndex, groupIndex) {
+    const bytes = new Uint8Array(32).fill(0);
+    bytes[30] = eventIndex;
+    bytes[31] = groupIndex;
+    return addressFromContractId(binToHex(bytes));
+}
+export const CreateContractEventAddresses = Array.from(Array(TOTAL_NUMBER_OF_GROUPS).keys()).map((groupIndex) => specialContractAddress(Contract.ContractCreatedEventIndex, groupIndex));
+export const DestroyContractEventAddresses = Array.from(Array(TOTAL_NUMBER_OF_GROUPS).keys()).map((groupIndex) => specialContractAddress(Contract.ContractDestroyedEventIndex, groupIndex));
+function decodeSystemEvent(event, eventSig, eventIndex) {
+    if (event.eventIndex !== eventIndex) {
+        throw new Error(`Invalid event index: ${event.eventIndex}, expected: ${eventIndex}`);
+    }
+    return fromApiEventFields(event.fields, eventSig, true);
+}
+function toContractCreatedEventFields(fields) {
+    const parentAddress = fields['parentAddress'];
+    const stdInterfaceId = fields['stdInterfaceId'];
+    return {
+        address: fields['address'],
+        parentAddress: parentAddress === '' ? undefined : parentAddress,
+        stdInterfaceIdGuessed: stdInterfaceId === '' ? undefined : stdInterfaceId
+    };
+}
+export function decodeContractCreatedEvent(event) {
+    const fields = decodeSystemEvent(event, Contract.ContractCreatedEvent, Contract.ContractCreatedEventIndex);
+    return {
+        blockHash: event.blockHash,
+        txId: event.txId,
+        eventIndex: event.eventIndex,
+        name: Contract.ContractCreatedEvent.name,
+        fields: toContractCreatedEventFields(fields)
+    };
+}
+export function decodeContractDestroyedEvent(event) {
+    const fields = decodeSystemEvent(event, Contract.ContractDestroyedEvent, Contract.ContractDestroyedEventIndex);
+    return {
+        blockHash: event.blockHash,
+        txId: event.txId,
+        eventIndex: event.eventIndex,
+        name: Contract.ContractDestroyedEvent.name,
+        fields: { address: fields['address'] }
+    };
+}
+export function subscribeEventsFromContract(options, address, eventIndex, decodeFunc, fromCount) {
+    const messageCallback = (event) => {
+        if (event.eventIndex !== eventIndex) {
+            return Promise.resolve();
+        }
+        return options.messageCallback(decodeFunc(event));
+    };
+    const errorCallback = (err, subscription) => {
+        return options.errorCallback(err, subscription);
+    };
+    const opt = {
+        pollingInterval: options.pollingInterval,
+        messageCallback: messageCallback,
+        errorCallback: errorCallback,
+        onEventCountChanged: options.onEventCountChanged,
+        parallel: options.parallel
+    };
+    return subscribeToEvents(opt, address, fromCount);
+}
+export function addStdIdToFields(contract, fields) {
+    const stdInterfaceIdPrefix = '414c5048';
+    return contract.stdInterfaceId === undefined
+        ? fields
+        : { ...fields, __stdInterfaceId: stdInterfaceIdPrefix + contract.stdInterfaceId };
+}
+function calcWrapperContractId(parentContractId, mapIndex, key, keyType, group) {
+    const prefix = ralph.encodeMapPrefix(mapIndex);
+    const encodedKey = ralph.encodeMapKey(key, keyType);
+    const path = binToHex(prefix) + binToHex(encodedKey);
+    return subContractId(parentContractId, path, group);
+}
+function genCodeForType(type, structs) {
+    const { immFields, mutFields } = ralph.calcFieldSize(type, true, structs);
+    const loadImmFieldByIndex = {
+        isPublic: true,
+        usePreapprovedAssets: false,
+        useContractAssets: false,
+        usePayToContractOnly: false,
+        argsLength: 1,
+        localsLength: 1,
+        returnLength: 1,
+        instrs: [LoadLocal(0), LoadImmFieldByIndex]
+    };
+    const loadMutFieldByIndex = {
+        ...loadImmFieldByIndex,
+        instrs: [LoadLocal(0), LoadMutFieldByIndex]
+    };
+    const parentContractIdIndex = immFields;
+    const storeMutFieldByIndex = {
+        ...loadImmFieldByIndex,
+        argsLength: 2,
+        localsLength: 2,
+        returnLength: 0,
+        instrs: [
+            CallerContractId,
+            LoadImmField(parentContractIdIndex),
+            ByteVecEq,
+            Assert,
+            LoadLocal(0),
+            LoadLocal(1),
+            StoreMutFieldByIndex
+        ]
+    };
+    const destroy = {
+        isPublic: true,
+        usePreapprovedAssets: false,
+        useContractAssets: true,
+        usePayToContractOnly: false,
+        argsLength: 1,
+        localsLength: 1,
+        returnLength: 0,
+        instrs: [CallerContractId, LoadImmField(parentContractIdIndex), ByteVecEq, Assert, LoadLocal(0), DestroySelf]
+    };
+    const c = {
+        fieldLength: immFields + mutFields + 1,
+        methods: [loadImmFieldByIndex, loadMutFieldByIndex, storeMutFieldByIndex, destroy]
+    };
+    const bytecode = contract.contractCodec.encodeContract(c);
+    const codeHash = blake2b(bytecode, { dkLen: 32 });
+    return { bytecode: binToHex(bytecode), codeHash: binToHex(codeHash) };
+}
+function getContractFieldsSig(mapValueType) {
+    return {
+        names: ['value', 'parentContractId'],
+        types: [mapValueType, 'ByteVec'],
+        isMutable: [true, false]
+    };
+}
+function mapToExistingContracts(contract, parentContractId, group, map, mapIndex, type) {
+    const [keyType, valueType] = ralph.parseMapType(type);
+    const generatedContract = genCodeForType(valueType, contract.structs);
+    return Array.from(map.entries()).map(([key, value]) => {
+        const fields = { value, parentContractId };
+        const contractId = calcWrapperContractId(parentContractId, mapIndex, key, keyType, group);
+        return {
+            ...generatedContract,
+            address: addressFromContractId(contractId),
+            contractId: contractId,
+            fieldsSig: getContractFieldsSig(valueType),
+            fields,
+            asset: { alphAmount: ONE_ALPH }
+        };
+    });
+}
+function mapsToExistingContracts(contract, parentContractId, group, initialMaps) {
+    const mapsSig = contract.mapsSig;
+    if (mapsSig === undefined)
+        return [];
+    const contractStates = [];
+    Object.keys(initialMaps).forEach((name) => {
+        const index = mapsSig.names.findIndex((n) => n === name);
+        if (index === -1)
+            throw new Error(`Map var ${name} does not exist in contract ${contract.name}`);
+        const mapType = mapsSig.types[`${index}`];
+        const states = mapToExistingContracts(contract, parentContractId, group, initialMaps[`${name}`], index, mapType);
+        contractStates.push(...states);
+    });
+    return contractStates;
+}
+function hasMap(state) {
+    return state.maps !== undefined;
+}
+function getTestExistingContracts(selfContract, selfContractId, group, params, getContractByCodeHash) {
+    const selfMaps = params.initialMaps ?? {};
+    const selfMapEntries = mapsToExistingContracts(selfContract, selfContractId, group, selfMaps);
+    const existingContracts = params.existingContracts ?? [];
+    const existingMapEntries = existingContracts.flatMap((contractState) => {
+        return hasMap(contractState)
+            ? mapsToExistingContracts(getContractByCodeHash(contractState.codeHash), contractState.contractId, group, contractState.maps ?? {})
+            : [];
+    });
+    return existingContracts.concat(selfMapEntries, existingMapEntries);
+}
+function getNewCreatedContractExceptMaps(result, getContractByCodeHash) {
+    const isMapContract = (codeHash) => {
+        try {
+            getContractByCodeHash(codeHash);
+            return false;
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes('Unknown code with code hash')) {
+                return true;
+            }
+            throw error;
+        }
+    };
+    const states = [];
+    result.events.forEach((event) => {
+        if (event.eventIndex === Contract.ContractCreatedEventIndex) {
+            const contractAddress = event.fields[0].value;
+            const contractState = result.contracts.find((c) => c.address === contractAddress);
+            if (contractState !== undefined && !isMapContract(contractState.codeHash)) {
+                states.push(contractState);
+            }
+        }
+    });
+    return states;
+}
+export function extractMapsFromApiResult(selfAddress, params, group, apiResult, getContractByCodeHash) {
+    const selfMaps = params.initialMaps ?? {};
+    const existingContracts = params.existingContracts ?? [];
+    const updatedExistingContracts = apiResult.contracts.filter((c) => c.address === selfAddress || existingContracts.find((s) => s.address === c.address) !== undefined);
+    const newCreateContracts = getNewCreatedContractExceptMaps(apiResult, getContractByCodeHash);
+    const allMaps = [];
+    updatedExistingContracts.concat(newCreateContracts).forEach((state) => {
+        const artifact = getContractByCodeHash(state.codeHash);
+        if (artifact.mapsSig !== undefined) {
+            const originMaps = state.address === selfAddress ? selfMaps : existingContracts.find((s) => s.address === state.address)?.maps;
+            const maps = existingContractsToMaps(artifact, state.address, group, apiResult, originMaps ?? {});
+            allMaps.push({ address: state.address, maps });
+        }
+    });
+    return allMaps;
+}
+export async function testMethod(factory, methodName, params, getContractByCodeHash) {
+    const txId = params?.txId ?? randomTxId();
+    const selfContract = factory.contract;
+    const selfAddress = params.contractAddress ?? addressFromContractId(binToHex(crypto.getRandomValues(new Uint8Array(32))));
+    const selfContractId = binToHex(contractIdFromAddress(selfAddress));
+    const group = params.group ?? 0;
+    const existingContracts = getTestExistingContracts(selfContract, selfContractId, group, params, getContractByCodeHash);
+    const apiParams = selfContract.toApiTestContractParams(methodName, {
+        ...params,
+        contractAddress: selfAddress,
+        txId: txId,
+        initialFields: addStdIdToFields(selfContract, params.initialFields ?? {}),
+        args: params.args === undefined ? {} : params.args,
+        existingContracts
+    });
+    const apiResult = await getCurrentNodeProvider().contracts.postContractsTestContract(apiParams);
+    const allMaps = extractMapsFromApiResult(selfAddress, params, group, apiResult, getContractByCodeHash);
+    const testResult = selfContract.fromApiTestContractResult(methodName, apiResult, txId, getContractByCodeHash);
+    testResult.contracts.forEach((c) => {
+        const maps = allMaps.find((v) => v.address === c.address)?.maps;
+        if (maps !== undefined)
+            c['maps'] = maps;
+    });
+    selfContract.printDebugMessages(methodName, testResult.debugMessages);
+    return {
+        ...testResult,
+        maps: allMaps.find((v) => v.address === selfAddress)?.maps
+    };
+}
+function printDebugMessage(m) {
+    console.log(`> Contract @ ${m.contractAddress} - ${m.message}`);
+}
+export async function getDebugMessagesFromTx(txId, provider) {
+    if (isHexString(txId) && txId.length === 64) {
+        const nodeProvider = provider ?? getCurrentNodeProvider();
+        const events = await nodeProvider.events.getEventsTxIdTxid(txId);
+        return events.events
+            .filter((e) => e.eventIndex === Contract.DebugEventIndex)
+            .map((e) => {
+            if (e.fields.length === 1 && e.fields[0].type === 'ByteVec') {
+                return {
+                    contractAddress: e.contractAddress,
+                    message: hexToString(e.fields[0].value)
+                };
+            }
+            else {
+                throw new Error(`Invalid debug log: ${stringify(e.fields)}`);
+            }
+        });
+    }
+    else {
+        throw new Error(`Invalid tx id: ${txId}`);
+    }
+}
+export async function printDebugMessagesFromTx(txId, provider) {
+    const messages = await getDebugMessagesFromTx(txId, provider);
+    if (messages.length > 0) {
+        messages.forEach((m) => printDebugMessage(m));
+    }
+}
+export class RalphMap {
+    constructor(parentContract, parentContractId, mapName) {
+        this.parentContract = parentContract;
+        this.parentContractId = parentContractId;
+        this.mapName = mapName;
+        this.groupIndex = groupOfAddress(addressFromContractId(parentContractId));
+    }
+    async get(key) {
+        return getMapItem(this.parentContract, this.parentContractId, this.groupIndex, this.mapName, key);
+    }
+    async contains(key) {
+        return this.get(key).then((v) => v !== undefined);
+    }
+    toJSON() {
+        return {
+            parentContractId: this.parentContractId,
+            mapName: this.mapName,
+            groupIndex: this.groupIndex
+        };
+    }
+}
+export async function getMapItem(parentContract, parentContractId, groupIndex, mapName, key) {
+    const index = parentContract.mapsSig?.names.findIndex((name) => name === mapName);
+    const mapType = index === undefined ? undefined : parentContract.mapsSig?.types[`${index}`];
+    if (mapType === undefined) {
+        throw new Error(`Map ${mapName} does not exist in contract ${parentContract.name}`);
+    }
+    const [keyType, valueType] = ralph.parseMapType(mapType);
+    const mapItemContractId = calcWrapperContractId(parentContractId, index, key, keyType, groupIndex);
+    const mapItemAddress = addressFromContractId(mapItemContractId);
+    try {
+        const state = await getCurrentNodeProvider().contracts.getContractsAddressState(mapItemAddress);
+        const fieldsSig = getContractFieldsSig(valueType);
+        const fields = fromApiFields(state.immFields, state.mutFields, fieldsSig, parentContract.structs);
+        return fields['value'];
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.includes('KeyNotFound')) {
+            return undefined;
+        }
+        throw new TraceableError(`Failed to get value from map ${mapName}, key: ${key}, parent contract id: ${parentContractId}`, error);
+    }
+}
+function buildMapInfo(contract, fields) {
+    const mapsSig = contract.mapsSig;
+    if (mapsSig === undefined)
+        return [];
+    return mapsSig.names.map((name, index) => {
+        const mapType = mapsSig.types[`${index}`];
+        const value = (fields[`${name}`] ?? new Map());
+        const [keyType, valueType] = ralph.parseMapType(mapType);
+        return { name, value, keyType, valueType, index };
+    });
+}
+function extractFromEventLog(contract, result, allMaps, address, group) {
+    const parentContractId = binToHex(contractIdFromAddress(address));
+    const newInserted = [];
+    result.debugMessages.forEach((message) => {
+        if (message.contractAddress !== address)
+            return;
+        const decoded = ralph.tryDecodeMapDebugLog(message.message);
+        if (decoded === undefined)
+            return;
+        const map = allMaps[`${decoded.mapIndex}`];
+        const decodedKey = ralph.decodePrimitive(decoded.encodedKey, map.keyType);
+        const contractId = subContractId(parentContractId, decoded.path, group);
+        if (!decoded.isInsert) {
+            map.value.delete(decodedKey);
+            return;
+        }
+        const state = result.contracts.find((s) => s.address === addressFromContractId(contractId));
+        if (state === undefined) {
+            throw new Error(`Cannot find contract state for map value, map field: ${map.name}, value type: ${map.valueType}`);
+        }
+        newInserted.push(state.address);
+        const fieldsSig = getContractFieldsSig(map.valueType);
+        const fields = fromApiFields(state.immFields, state.mutFields, fieldsSig, contract.structs);
+        map.value.set(decodedKey, fields['value']);
+    });
+    return newInserted;
+}
+function updateMaps(contract, result, allMaps, address, group) {
+    const parentContractId = binToHex(contractIdFromAddress(address));
+    const updated = [];
+    allMaps.forEach((map) => {
+        Array.from(map.value.keys()).forEach((key) => {
+            const contractId = calcWrapperContractId(parentContractId, map.index, key, map.keyType, group);
+            const updatedState = result.contracts.find((s) => s.address === addressFromContractId(contractId));
+            if (updatedState === undefined)
+                return;
+            updated.push(updatedState.address);
+            const fieldsSig = getContractFieldsSig(map.valueType);
+            const fields = fromApiFields(updatedState.immFields, updatedState.mutFields, fieldsSig, contract.structs);
+            map.value.set(key, fields['value']);
+        });
+    });
+    return updated;
+}
+function existingContractsToMaps(contract, address, group, result, maps) {
+    const allMaps = buildMapInfo(contract, maps);
+    const updated = updateMaps(contract, result, allMaps, address, group);
+    const newInserted = extractFromEventLog(contract, result, allMaps, address, group);
+    const mapEntries = updated.concat(newInserted);
+    const remainContracts = result.contracts.filter((c) => mapEntries.find((addr) => c.address === addr) === undefined);
+    result.contracts = remainContracts;
+    return allMaps.reduce((acc, map) => {
+        acc[`${map.name}`] = map.value;
+        return acc;
+    }, {});
+}
+export class ContractInstance {
+    constructor(address) {
+        this.address = address;
+        this.contractId = binToHex(contractIdFromAddress(address));
+        this.groupIndex = groupOfAddress(address);
+    }
+}
+export async function fetchContractState(contract, instance) {
+    const contractState = await getCurrentNodeProvider().contracts.getContractsAddressState(instance.address);
+    const state = contract.contract.fromApiContractState(contractState);
+    return {
+        ...state,
+        fields: state.fields
+    };
+}
+function checkGroupIndex(groupIndex) {
+    if (groupIndex < 0 || groupIndex >= TOTAL_NUMBER_OF_GROUPS) {
+        throw new Error(`Invalid group index ${groupIndex}, expected a value within the range [0, ${TOTAL_NUMBER_OF_GROUPS})`);
+    }
+}
+export function subscribeContractCreatedEvent(options, fromGroup, fromCount) {
+    checkGroupIndex(fromGroup);
+    const contractAddress = CreateContractEventAddresses[`${fromGroup}`];
+    return subscribeEventsFromContract(options, contractAddress, Contract.ContractCreatedEventIndex, (event) => {
+        return {
+            ...decodeContractCreatedEvent(event),
+            contractAddress: contractAddress
+        };
+    }, fromCount);
+}
+export function subscribeContractDestroyedEvent(options, fromGroup, fromCount) {
+    checkGroupIndex(fromGroup);
+    const contractAddress = DestroyContractEventAddresses[`${fromGroup}`];
+    return subscribeEventsFromContract(options, contractAddress, Contract.ContractDestroyedEventIndex, (event) => {
+        return {
+            ...decodeContractDestroyedEvent(event),
+            contractAddress: contractAddress
+        };
+    }, fromCount);
+}
+export function decodeEvent(contract, instance, event, targetEventIndex) {
+    if (event.eventIndex !== targetEventIndex &&
+        !(targetEventIndex >= 0 && targetEventIndex < contract.eventsSig.length)) {
+        throw new Error('Invalid event index: ' + event.eventIndex + ', expected: ' + targetEventIndex);
+    }
+    const eventSig = contract.eventsSig[`${targetEventIndex}`];
+    const fields = fromApiEventFields(event.fields, eventSig);
+    return {
+        contractAddress: instance.address,
+        blockHash: event.blockHash,
+        txId: event.txId,
+        eventIndex: event.eventIndex,
+        name: eventSig.name,
+        fields: fields
+    };
+}
+export function subscribeContractEvent(contract, instance, options, eventName, fromCount) {
+    const eventIndex = contract.eventsSig.findIndex((sig) => sig.name === eventName);
+    return subscribeEventsFromContract(options, instance.address, eventIndex, (event) => decodeEvent(contract, instance, event, eventIndex), fromCount);
+}
+export function subscribeContractEvents(contract, instance, options, fromCount) {
+    const messageCallback = (event) => {
+        return options.messageCallback({
+            ...decodeEvent(contract, instance, event, event.eventIndex),
+            contractAddress: instance.address
+        });
+    };
+    const errorCallback = (err, subscription) => {
+        return options.errorCallback(err, subscription);
+    };
+    const opt = {
+        pollingInterval: options.pollingInterval,
+        messageCallback: messageCallback,
+        errorCallback: errorCallback,
+        onEventCountChanged: options.onEventCountChanged,
+        parallel: options.parallel
+    };
+    return subscribeToEvents(opt, instance.address, fromCount);
+}
+export async function callMethod(contract, instance, methodName, params, getContractByCodeHash) {
+    const methodIndex = contract.contract.getMethodIndex(methodName);
+    const txId = params?.txId ?? randomTxId();
+    const callArgs = getCallMethodArgs(params.args ?? {}, instance.groupIndex);
+    const callParams = contract.contract.toApiCallContract({ ...params, txId: txId, args: callArgs }, instance.groupIndex, instance.address, methodIndex);
+    const result = await getCurrentNodeProvider().contracts.postContractsCallContract(callParams);
+    const callResult = contract.contract.fromApiCallContractResult(result, txId, methodIndex, getContractByCodeHash);
+    contract.contract.printDebugMessages(methodName, callResult.debugMessages);
+    return callResult;
+}
+function tryGetCallMethodAddressArg(maybeAddress, groupIndex) {
+    if (!isValidAddress(maybeAddress))
+        return maybeAddress;
+    if (isGrouplessAddress(maybeAddress)) {
+        const rawAddress = addressWithoutExplicitGroupIndex(maybeAddress);
+        return `${rawAddress}:${groupIndex}`;
+    }
+    return maybeAddress;
+}
+function getCallMethodArgsFromVal(val, groupIndex) {
+    if (typeof val === 'string') {
+        return tryGetCallMethodAddressArg(val, groupIndex);
+    }
+    if (Array.isArray(val)) {
+        return val.map((v) => getCallMethodArgsFromVal(v, groupIndex));
+    }
+    return val;
+}
+function getCallMethodArgs(args, groupIndex) {
+    const newArgs = {};
+    for (const [key, value] of Object.entries(args)) {
+        newArgs[`${key}`] = getCallMethodArgsFromVal(value, groupIndex);
+    }
+    return newArgs;
+}
+export async function signExecuteMethod(contract, instance, methodName, params) {
+    const methodIndex = contract.contract.getMethodIndex(methodName);
+    const functionSig = contract.contract.functions[methodIndex];
+    const isDevnet = await contract.contract.isDevnet(params.signer);
+    const methodUsePreapprovedAssets = contract.contract.isMethodUsePreapprovedAssets(isDevnet, methodIndex);
+    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;
+    const selectedAccount = await signer.getSelectedAccount();
+    const signerParams = {
+        signerAddress: selectedAccount.address,
+        signerKeyType: selectedAccount.keyType,
+        bytecode: bytecode,
+        attoAlphAmount: params.attoAlphAmount,
+        tokens: params.tokens,
+        gasAmount: params.gasAmount,
+        gasPrice: params.gasPrice,
+        group: instance.groupIndex,
+        dustAmount: params.dustAmount
+    };
+    const result = (await signer.signAndSubmitExecuteScriptTx(signerParams));
+    if (isContractDebugMessageEnabled() && isDevnet) {
+        await printDebugMessagesFromTx(result.txId, signer.nodeProvider);
+    }
+    return result;
+}
+function getBytecodeTemplate(methodIndex, methodUsePreapprovedAssets, functionSig, structs, attoAlphAmount, tokens) {
+    const numberOfMethods = '01';
+    const isPublic = '01';
+    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(methodUsePreapprovedAssets ? attoAlphAmount : undefined);
+    const approveTokensInstrs = getApproveTokensInstrs(methodUsePreapprovedAssets ? tokens : undefined);
+    const callerInstrs = getCallAddressInstrs(approveAlphInstrs.length / 2 + approveTokensInstrs.length / 3);
+    const functionArgsNum = encodeU256Const(BigInt(templateVarsLength - 1));
+    const localsLength = encodeI32(templateVarStoreLocalInstrs.length / 2);
+    const templateVarLoadLocalInstrs = getTemplateVarLoadLocalInstrs(functionSig, structs);
+    const functionReturnTypesLength = functionSig.returnTypes.reduce((acc, returnType) => acc + ralph.typeLength(returnType, structs), 0);
+    const functionReturnPopInstrs = encodeInstr(Pop).repeat(functionReturnTypesLength);
+    const functionReturnNum = encodeU256Const(BigInt(functionReturnTypesLength));
+    const contractTemplateVar = '{0}';
+    const externalCallInstr = encodeInstr(CallExternal(methodIndex));
+    const numberOfInstrs = encodeI32(callerInstrs.length +
+        approveAlphInstrs.length +
+        approveTokensInstrs.length +
+        templateVarStoreLocalInstrs.length +
+        templateVarLoadLocalInstrs.length +
+        functionReturnTypesLength +
+        4);
+    return (numberOfMethods +
+        isPublic +
+        modifier +
+        argsLength +
+        localsLength +
+        returnsLength +
+        numberOfInstrs +
+        callerInstrs.join('') +
+        approveAlphInstrs.join('') +
+        approveTokensInstrs.join('') +
+        templateVarStoreLocalInstrs.join('') +
+        templateVarLoadLocalInstrs.join('') +
+        functionArgsNum +
+        functionReturnNum +
+        contractTemplateVar +
+        externalCallInstr +
+        functionReturnPopInstrs);
+}
+function getApproveAlphInstrs(attoAlphAmount) {
+    const approveAlphInstrs = [];
+    if (attoAlphAmount) {
+        const approvedAttoAlphAmount = encodeU256Const(BigInt(attoAlphAmount));
+        approveAlphInstrs.push(approvedAttoAlphAmount);
+        approveAlphInstrs.push(encodeInstr(ApproveAlph));
+    }
+    return approveAlphInstrs;
+}
+function getApproveTokensInstrs(tokens) {
+    const approveTokensInstrs = [];
+    if (tokens) {
+        tokens.forEach((token) => {
+            const tokenIdBin = hexToBinUnsafe(token.id);
+            approveTokensInstrs.push(encodeInstr(BytesConst(tokenIdBin)));
+            approveTokensInstrs.push(encodeU256Const(BigInt(token.amount)));
+            approveTokensInstrs.push(encodeInstr(ApproveToken));
+        });
+    }
+    return approveTokensInstrs;
+}
+function getCallAddressInstrs(approveAssetsNum) {
+    const callerInstrs = [];
+    if (approveAssetsNum > 0) {
+        callerInstrs.push(encodeInstr(CallerAddress));
+        const dup = encodeInstr(Dup);
+        if (approveAssetsNum > 1) {
+            callerInstrs.push(...new Array(approveAssetsNum - 1).fill(dup));
+        }
+    }
+    return callerInstrs;
+}
+function getTemplateVarStoreLocalInstrs(functionSig, structs) {
+    let templateVarIndex = 1;
+    let localsLength = 0;
+    const templateVarStoreInstrs = [];
+    functionSig.paramTypes.forEach((paramType) => {
+        const fieldsLength = ralph.typeLength(paramType, structs);
+        if (fieldsLength > 1) {
+            for (let i = 0; i < fieldsLength; i++) {
+                templateVarStoreInstrs.push(`{${templateVarIndex + i}}`);
+            }
+            for (let i = 0; i < fieldsLength; i++) {
+                templateVarStoreInstrs.push(encodeStoreLocalInstr(localsLength + (fieldsLength - i - 1)));
+            }
+            localsLength = localsLength + fieldsLength;
+        }
+        templateVarIndex = templateVarIndex + fieldsLength;
+    });
+    return [templateVarStoreInstrs, templateVarIndex];
+}
+function getTemplateVarLoadLocalInstrs(functionSig, structs) {
+    let templateVarIndex = 1;
+    let loadIndex = 0;
+    const templateVarLoadInstrs = [];
+    functionSig.paramTypes.forEach((paramType) => {
+        const fieldsLength = ralph.typeLength(paramType, structs);
+        if (fieldsLength === 1) {
+            templateVarLoadInstrs.push(`{${templateVarIndex}}`);
+        }
+        if (fieldsLength > 1) {
+            for (let i = 0; i < fieldsLength; i++) {
+                templateVarLoadInstrs.push(encodeLoadLocalInstr(loadIndex + i));
+            }
+            loadIndex = loadIndex + fieldsLength;
+        }
+        templateVarIndex = templateVarIndex + fieldsLength;
+    });
+    return templateVarLoadInstrs;
+}
+function encodeStoreLocalInstr(index) {
+    if (index < 0 || index > 0xff) {
+        throw new Error(`StoreLocal index ${index} must be between 0 and 255 inclusive`);
+    }
+    return encodeInstr(StoreLocal(index));
+}
+function encodeLoadLocalInstr(index) {
+    if (index < 0 || index > 0xff) {
+        throw new Error(`LoadLocal index ${index} must be between 0 and 255 inclusive`);
+    }
+    return encodeInstr(LoadLocal(index));
+}
+function encodeI32(value) {
+    return binToHex(i32Codec.encode(value));
+}
+function encodeU256Const(value) {
+    if (value < 0) {
+        throw new Error(`value ${value} must be non-negative`);
+    }
+    if (value < 6) {
+        return (BigInt(0x0c) + value).toString(16).padStart(2, '0');
+    }
+    else {
+        return encodeInstr(U256Const(value));
+    }
+}
+function encodeInstr(instr) {
+    return binToHex(instrCodec.encode(instr));
+}
+function toFieldsSig(contractName, functionSig) {
+    return {
+        names: ['__contract__'].concat(functionSig.paramNames),
+        types: [contractName].concat(functionSig.paramTypes),
+        isMutable: [false].concat(functionSig.paramIsMutable)
+    };
+}
+export async function multicallMethods(contract, instance, _callss, getContractByCodeHash) {
+    const callss = Array.isArray(_callss) ? _callss : [_callss];
+    const callEntries = callss.map((calls) => Object.entries(calls));
+    const callsParams = callEntries.map((entries) => {
+        return entries.map((entry) => {
+            const [methodName, params] = entry;
+            const methodIndex = contract.contract.getMethodIndex(methodName);
+            const txId = params?.txId ?? randomTxId();
+            const callArgs = getCallMethodArgs(params.args ?? {}, instance.groupIndex);
+            return contract.contract.toApiCallContract({ ...params, txId: txId, args: callArgs }, instance.groupIndex, instance.address, methodIndex);
+        });
+    });
+    const result = await getCurrentNodeProvider().contracts.postContractsMulticallContract({ calls: callsParams.flat() });
+    let callResultIndex = 0;
+    const results = callsParams.map((calls, index0) => {
+        const callsResult = {};
+        const entries = callEntries[`${index0}`];
+        calls.forEach((call, index1) => {
+            const methodIndex = call.methodIndex;
+            const callResult = result.results[`${callResultIndex}`];
+            const methodName = entries[`${index1}`][`0`];
+            callsResult[`${methodName}`] = contract.contract.fromApiCallContractResult(callResult, call.txId, methodIndex, getContractByCodeHash);
+            callResultIndex += 1;
+        });
+        return callsResult;
+    });
+    return Array.isArray(_callss) ? results : results[0];
+}
+export async function getContractEventsCurrentCount(contractAddress) {
+    return getCurrentNodeProvider()
+        .events.getEventsContractContractaddressCurrentCount(contractAddress)
+        .catch((error) => {
+        if (error instanceof Error && error.message.includes(`${contractAddress} not found`)) {
+            return 0;
+        }
+        throw new TraceableError(`Failed to get the event count for the contract ${contractAddress}`, error);
+    });
+}
+export const getContractIdFromUnsignedTx = async (nodeProvider, unsignedTx) => {
+    const result = await nodeProvider.transactions.postTransactionsDecodeUnsignedTx({ unsignedTx });
+    const outputIndex = result.unsignedTx.fixedOutputs.length;
+    const hex = result.unsignedTx.txId + outputIndex.toString(16).padStart(8, '0');
+    const hashHex = binToHex(blake2b(hexToBinUnsafe(hex), { dkLen: 32 }));
+    return hashHex.slice(0, 62) + result.fromGroup.toString(16).padStart(2, '0');
+};
+export const getTokenIdFromUnsignedTx = getContractIdFromUnsignedTx;
+export async function getContractCodeByCodeHash(nodeProvider, codeHash) {
+    if (isHexString(codeHash) && codeHash.length === 64) {
+        try {
+            return await nodeProvider.contracts.getContractsCodehashCode(codeHash);
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes('not found')) {
+                return undefined;
+            }
+            throw new TraceableError(`Failed to get contract by code hash ${codeHash}`, error);
+        }
+    }
+    throw new Error(`Invalid code hash: ${codeHash}`);
+}
+//# sourceMappingURL=contract.js.map