@alephium/web3 0.8.2-test.3 → 0.9.0-rc.0

package/dist/src/contract/contract.js

@@ -1,1079 +0,0 @@
-"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/>.
-*/
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getContractEventsCurrentCount = exports.multicallMethods = exports.callMethod = exports.subscribeContractEvents = exports.subscribeContractEvent = exports.decodeEvent = exports.subscribeContractDestroyedEvent = exports.subscribeContractCreatedEvent = exports.fetchContractState = exports.ContractInstance = exports.testMethod = exports.subscribeEventsFromContract = exports.decodeContractDestroyedEvent = exports.decodeContractCreatedEvent = exports.DestroyContractEventAddress = exports.CreateContractEventAddress = exports.ContractFactory = exports.randomTxId = exports.toApiVals = exports.Script = exports.Contract = exports.Artifact = exports.Project = exports.DEFAULT_COMPILER_OPTIONS = exports.DEFAULT_NODE_COMPILER_OPTIONS = void 0;
-const buffer_1 = require("buffer/");
-const crypto_1 = require("crypto");
-const fs_1 = __importDefault(require("fs"));
-const fs_2 = require("fs");
-const api_1 = require("../api");
-const ralph = __importStar(require("./ralph"));
-const utils_1 = require("../utils");
-const global_1 = require("../global");
-const path = __importStar(require("path"));
-const events_1 = require("./events");
-const constants_1 = require("../constants");
-var SourceKind;
-(function (SourceKind) {
-    SourceKind[SourceKind["Contract"] = 0] = "Contract";
-    SourceKind[SourceKind["Script"] = 1] = "Script";
-    SourceKind[SourceKind["AbstractContract"] = 2] = "AbstractContract";
-    SourceKind[SourceKind["Interface"] = 3] = "Interface";
-})(SourceKind || (SourceKind = {}));
-exports.DEFAULT_NODE_COMPILER_OPTIONS = {
-    ignoreUnusedConstantsWarnings: false,
-    ignoreUnusedVariablesWarnings: false,
-    ignoreUnusedFieldsWarnings: false,
-    ignoreUnusedPrivateFunctionsWarnings: false,
-    ignoreUpdateFieldsCheckWarnings: false,
-    ignoreCheckExternalCallerWarnings: false
-};
-exports.DEFAULT_COMPILER_OPTIONS = { errorOnWarnings: true, ...exports.DEFAULT_NODE_COMPILER_OPTIONS };
-class TypedMatcher {
-    constructor(pattern, type) {
-        this.matcher = new RegExp(pattern, 'mg');
-        this.type = type;
-    }
-}
-function removeParentsPrefix(parts) {
-    let index = 0;
-    for (let i = 0; i < parts.length; i++) {
-        if (parts[`${i}`] === '..') {
-            index += 1;
-        }
-        else {
-            break;
-        }
-    }
-    return path.join(...parts.slice(index));
-}
-class SourceInfo {
-    constructor(type, name, sourceCode, sourceCodeHash, contractRelativePath, isExternal) {
-        this.type = type;
-        this.name = name;
-        this.sourceCode = sourceCode;
-        this.sourceCodeHash = sourceCodeHash;
-        this.contractRelativePath = contractRelativePath;
-        this.isExternal = isExternal;
-    }
-    getArtifactPath(artifactsRootDir) {
-        if (this.isExternal) {
-            const relativePath = removeParentsPrefix(this.contractRelativePath.split(path.sep));
-            const externalPath = path.join('.external', relativePath);
-            return path.join(artifactsRootDir, externalPath) + '.json';
-        }
-        return path.join(artifactsRootDir, this.contractRelativePath) + '.json';
-    }
-    static async from(type, name, sourceCode, contractRelativePath, isExternal) {
-        const sourceCodeHash = await crypto_1.webcrypto.subtle.digest('SHA-256', buffer_1.Buffer.from(sourceCode));
-        const sourceCodeHashHex = buffer_1.Buffer.from(sourceCodeHash).toString('hex');
-        return new SourceInfo(type, name, sourceCode, sourceCodeHashHex, contractRelativePath, isExternal);
-    }
-}
-class Compiled {
-    constructor(sourceInfo, artifact, warnings) {
-        this.sourceInfo = sourceInfo;
-        this.artifact = artifact;
-        this.warnings = warnings;
-    }
-}
-class ProjectArtifact {
-    constructor(compilerOptionsUsed, infos) {
-        ProjectArtifact.checkCompilerOptionsParameter(compilerOptionsUsed);
-        this.compilerOptionsUsed = compilerOptionsUsed;
-        this.infos = infos;
-    }
-    static checkCompilerOptionsParameter(compilerOptions) {
-        if (Object.keys(compilerOptions).length != Object.keys(exports.DEFAULT_NODE_COMPILER_OPTIONS).length) {
-            throw Error(`Not all compiler options are set: ${compilerOptions}`);
-        }
-        const combined = { ...compilerOptions, ...exports.DEFAULT_NODE_COMPILER_OPTIONS };
-        if (Object.keys(combined).length !== Object.keys(exports.DEFAULT_NODE_COMPILER_OPTIONS).length) {
-            throw Error(`There are unknown compiler options: ${compilerOptions}`);
-        }
-    }
-    async saveToFile(rootPath) {
-        const filepath = path.join(rootPath, ProjectArtifact.artifactFileName);
-        const artifact = {
-            compilerOptionsUsed: this.compilerOptionsUsed,
-            infos: Object.fromEntries(new Map([...this.infos].sort()))
-        };
-        const content = JSON.stringify(artifact, null, 2);
-        return fs_2.promises.writeFile(filepath, content);
-    }
-    needToReCompile(compilerOptions, sourceInfos) {
-        ProjectArtifact.checkCompilerOptionsParameter(compilerOptions);
-        const optionsMatched = Object.entries(compilerOptions).every(([key, inputOption]) => {
-            const usedOption = this.compilerOptionsUsed[`${key}`];
-            return usedOption === inputOption;
-        });
-        if (!optionsMatched) {
-            return true;
-        }
-        if (sourceInfos.length !== this.infos.size) {
-            return true;
-        }
-        for (const sourceInfo of sourceInfos) {
-            const info = this.infos.get(sourceInfo.name);
-            if (typeof info === 'undefined' || info.sourceCodeHash !== sourceInfo.sourceCodeHash) {
-                return true;
-            }
-        }
-        return false;
-    }
-    static async from(rootPath) {
-        const filepath = path.join(rootPath, ProjectArtifact.artifactFileName);
-        if (!fs_1.default.existsSync(filepath)) {
-            return undefined;
-        }
-        const content = await fs_2.promises.readFile(filepath);
-        const json = JSON.parse(content.toString());
-        const compilerOptionsUsed = json.compilerOptionsUsed;
-        const files = new Map(Object.entries(json.infos));
-        return new ProjectArtifact(compilerOptionsUsed, files);
-    }
-}
-ProjectArtifact.artifactFileName = '.project.json';
-class Project {
-    constructor(contractsRootDir, artifactsRootDir, sourceInfos, contracts, scripts, errorOnWarnings, projectArtifact) {
-        this.contractsRootDir = contractsRootDir;
-        this.artifactsRootDir = artifactsRootDir;
-        this.sourceInfos = sourceInfos;
-        this.contracts = contracts;
-        this.scripts = scripts;
-        this.projectArtifact = projectArtifact;
-        if (errorOnWarnings) {
-            Project.checkCompilerWarnings([
-                ...[...contracts.entries()].map((c) => c[1].warnings).flat(),
-                ...[...scripts.entries()].map((s) => s[1].warnings).flat()
-            ], errorOnWarnings);
-        }
-    }
-    static buildProjectArtifact(sourceInfos, contracts, scripts, compilerOptions) {
-        const files = new Map();
-        contracts.forEach((c) => {
-            files.set(c.artifact.name, {
-                sourceFile: c.sourceInfo.contractRelativePath,
-                sourceCodeHash: c.sourceInfo.sourceCodeHash,
-                bytecodeDebugPatch: c.artifact.bytecodeDebugPatch,
-                codeHashDebug: c.artifact.codeHashDebug,
-                warnings: c.warnings
-            });
-        });
-        scripts.forEach((s) => {
-            files.set(s.artifact.name, {
-                sourceFile: s.sourceInfo.contractRelativePath,
-                sourceCodeHash: s.sourceInfo.sourceCodeHash,
-                bytecodeDebugPatch: s.artifact.bytecodeDebugPatch,
-                codeHashDebug: '',
-                warnings: s.warnings
-            });
-        });
-        const compiledSize = contracts.size + scripts.size;
-        sourceInfos.slice(compiledSize).forEach((c) => {
-            files.set(c.name, {
-                sourceFile: c.contractRelativePath,
-                sourceCodeHash: c.sourceCodeHash,
-                bytecodeDebugPatch: '',
-                codeHashDebug: '',
-                warnings: []
-            });
-        });
-        return new ProjectArtifact(compilerOptions, files);
-    }
-    static checkCompilerWarnings(warnings, errorOnWarnings) {
-        if (warnings.length !== 0) {
-            const prefixPerWarning = '  - ';
-            const warningString = prefixPerWarning + warnings.join('\n' + prefixPerWarning);
-            const output = `Compilation warnings:\n` + warningString + '\n';
-            if (errorOnWarnings) {
-                throw new Error(output);
-            }
-            else {
-                console.log(output);
-            }
-        }
-    }
-    static contract(name) {
-        const contract = Project.currentProject.contracts.get(name);
-        if (typeof contract === 'undefined') {
-            throw new Error(`Contract "${name}" does not exist`);
-        }
-        return contract.artifact;
-    }
-    static script(name) {
-        const script = Project.currentProject.scripts.get(name);
-        if (typeof script === 'undefined') {
-            throw new Error(`Script "${name}" does not exist`);
-        }
-        return script.artifact;
-    }
-    async saveArtifactsToFile(projectRootDir) {
-        const artifactsRootDir = this.artifactsRootDir;
-        const saveToFile = async function (compiled) {
-            const artifactPath = compiled.sourceInfo.getArtifactPath(artifactsRootDir);
-            const dirname = path.dirname(artifactPath);
-            if (!fs_1.default.existsSync(dirname)) {
-                fs_1.default.mkdirSync(dirname, { recursive: true });
-            }
-            return fs_2.promises.writeFile(artifactPath, compiled.artifact.toString());
-        };
-        this.contracts.forEach((contract) => saveToFile(contract));
-        this.scripts.forEach((script) => saveToFile(script));
-        await this.projectArtifact.saveToFile(projectRootDir);
-    }
-    contractByCodeHash(codeHash) {
-        const contract = [...this.contracts.values()].find((c) => c.artifact.codeHash === codeHash || c.artifact.codeHashDebug == codeHash);
-        if (typeof contract === 'undefined') {
-            throw new Error(`Unknown code with code hash: ${codeHash}`);
-        }
-        return contract.artifact;
-    }
-    static async compile(provider, sourceInfos, projectRootDir, contractsRootDir, artifactsRootDir, errorOnWarnings, compilerOptions) {
-        const sourceStr = sourceInfos.map((f) => f.sourceCode).join('\n');
-        const result = await provider.contracts.postContractsCompileProject({
-            code: sourceStr,
-            compilerOptions: compilerOptions
-        });
-        const contracts = new Map();
-        const scripts = new Map();
-        result.contracts.forEach((contractResult, index) => {
-            const sourceInfo = sourceInfos[`${index}`];
-            const contract = Contract.fromCompileResult(contractResult);
-            contracts.set(contract.name, new Compiled(sourceInfo, contract, contractResult.warnings));
-        });
-        result.scripts.forEach((scriptResult, index) => {
-            const sourceInfo = sourceInfos[index + contracts.size];
-            const script = Script.fromCompileResult(scriptResult);
-            scripts.set(script.name, new Compiled(sourceInfo, script, scriptResult.warnings));
-        });
-        const projectArtifact = Project.buildProjectArtifact(sourceInfos, contracts, scripts, compilerOptions);
-        const project = new Project(contractsRootDir, artifactsRootDir, sourceInfos, contracts, scripts, errorOnWarnings, projectArtifact);
-        await project.saveArtifactsToFile(projectRootDir);
-        return project;
-    }
-    static async loadArtifacts(provider, sourceInfos, projectArtifact, projectRootDir, contractsRootDir, artifactsRootDir, errorOnWarnings, compilerOptions) {
-        try {
-            const contracts = new Map();
-            const scripts = new Map();
-            for (const sourceInfo of sourceInfos) {
-                const info = projectArtifact.infos.get(sourceInfo.name);
-                if (typeof info === 'undefined') {
-                    throw Error(`Unable to find project info for ${sourceInfo.name}, please rebuild the project`);
-                }
-                const warnings = info.warnings;
-                const artifactDir = sourceInfo.getArtifactPath(artifactsRootDir);
-                if (sourceInfo.type === SourceKind.Contract) {
-                    const artifact = await Contract.fromArtifactFile(artifactDir, info.bytecodeDebugPatch, info.codeHashDebug);
-                    contracts.set(artifact.name, new Compiled(sourceInfo, artifact, warnings));
-                }
-                else if (sourceInfo.type === SourceKind.Script) {
-                    const artifact = await Script.fromArtifactFile(artifactDir, info.bytecodeDebugPatch);
-                    scripts.set(artifact.name, new Compiled(sourceInfo, artifact, warnings));
-                }
-            }
-            return new Project(contractsRootDir, artifactsRootDir, sourceInfos, contracts, scripts, errorOnWarnings, projectArtifact);
-        }
-        catch (error) {
-            console.log(`Failed to load artifacts, error: ${error}, try to re-compile contracts...`);
-            return Project.compile(provider, sourceInfos, projectRootDir, contractsRootDir, artifactsRootDir, errorOnWarnings, compilerOptions);
-        }
-    }
-    static getImportSourcePath(projectRootDir, importPath) {
-        const parts = importPath.split('/');
-        if (parts.length > 1 && parts[0] === 'std') {
-            const currentDir = path.dirname(__filename);
-            return path.join(...[currentDir, '..', '..', '..', importPath]);
-        }
-        let moduleDir = projectRootDir;
-        while (true) {
-            const expectedPath = path.join(...[moduleDir, 'node_modules', importPath]);
-            if (fs_1.default.existsSync(expectedPath)) {
-                return expectedPath;
-            }
-            const oldModuleDir = moduleDir;
-            moduleDir = path.join(moduleDir, '..');
-            if (oldModuleDir === moduleDir) {
-                throw new Error(`Specified import file does not exist: ${importPath}`);
-            }
-        }
-    }
-    static async handleImports(projectRootDir, contractRootDir, sourceStr, importsCache) {
-        const localImportsCache = [];
-        const result = sourceStr.replace(Project.importRegex, (match) => {
-            localImportsCache.push(match);
-            return '';
-        });
-        const externalSourceInfos = [];
-        for (const myImport of localImportsCache) {
-            const originImportPath = myImport.slice(8, -1);
-            const importPath = originImportPath.endsWith('.ral') ? originImportPath : originImportPath + '.ral';
-            if (!importsCache.includes(importPath)) {
-                importsCache.push(importPath);
-                const sourcePath = Project.getImportSourcePath(projectRootDir, importPath);
-                const sourceInfos = await Project.loadSourceFile(projectRootDir, contractRootDir, sourcePath, importsCache, true);
-                externalSourceInfos.push(...sourceInfos);
-            }
-        }
-        return [result, externalSourceInfos];
-    }
-    static async loadSourceFile(projectRootDir, contractsRootDir, sourcePath, importsCache, isExternal) {
-        const contractRelativePath = path.relative(contractsRootDir, sourcePath);
-        if (!sourcePath.endsWith('.ral')) {
-            throw new Error(`Invalid filename: ${sourcePath}, smart contract file name should end with ".ral"`);
-        }
-        const sourceBuffer = await fs_2.promises.readFile(sourcePath);
-        const [sourceStr, externalSourceInfos] = await Project.handleImports(projectRootDir, contractsRootDir, sourceBuffer.toString(), importsCache);
-        if (sourceStr.match(new RegExp('^import "', 'mg')) !== null) {
-            throw new Error(`Invalid import statements, source: ${sourcePath}`);
-        }
-        const sourceInfos = externalSourceInfos;
-        for (const matcher of this.matchers) {
-            const results = sourceStr.matchAll(matcher.matcher);
-            for (const result of results) {
-                const sourceInfo = await SourceInfo.from(matcher.type, result[1], sourceStr, contractRelativePath, isExternal);
-                sourceInfos.push(sourceInfo);
-            }
-        }
-        return sourceInfos;
-    }
-    static async loadSourceFiles(projectRootDir, contractsRootDir) {
-        const importsCache = [];
-        const sourceInfos = [];
-        const loadDir = async function (dirPath) {
-            const dirents = await fs_2.promises.readdir(dirPath, { withFileTypes: true });
-            for (const dirent of dirents) {
-                if (dirent.isFile()) {
-                    const sourcePath = path.join(dirPath, dirent.name);
-                    const infos = await Project.loadSourceFile(projectRootDir, contractsRootDir, sourcePath, importsCache, false);
-                    sourceInfos.push(...infos);
-                }
-                else {
-                    const newPath = path.join(dirPath, dirent.name);
-                    await loadDir(newPath);
-                }
-            }
-        };
-        await loadDir(contractsRootDir);
-        const contractAndScriptSize = sourceInfos.filter((f) => f.type === SourceKind.Contract || f.type === SourceKind.Script).length;
-        if (sourceInfos.length === 0 || contractAndScriptSize === 0) {
-            throw new Error('Project have no source files');
-        }
-        return sourceInfos.sort((a, b) => a.type - b.type);
-    }
-    static async build(compilerOptionsPartial = {}, projectRootDir = '.', contractsRootDir = Project.DEFAULT_CONTRACTS_DIR, artifactsRootDir = Project.DEFAULT_ARTIFACTS_DIR) {
-        const provider = (0, global_1.getCurrentNodeProvider)();
-        const sourceFiles = await Project.loadSourceFiles(projectRootDir, contractsRootDir);
-        const { errorOnWarnings, ...nodeCompilerOptions } = { ...exports.DEFAULT_COMPILER_OPTIONS, ...compilerOptionsPartial };
-        const projectArtifact = await ProjectArtifact.from(projectRootDir);
-        if (typeof projectArtifact === 'undefined' || projectArtifact.needToReCompile(nodeCompilerOptions, sourceFiles)) {
-            console.log(`Compiling contracts in folder "${contractsRootDir}"`);
-            Project.currentProject = await Project.compile(provider, sourceFiles, projectRootDir, contractsRootDir, artifactsRootDir, errorOnWarnings, nodeCompilerOptions);
-        }
-        else {
-            console.log(`Contracts are compiled already. Loading them from folder "${artifactsRootDir}"`);
-            Project.currentProject = await Project.loadArtifacts(provider, sourceFiles, projectArtifact, projectRootDir, contractsRootDir, artifactsRootDir, errorOnWarnings, nodeCompilerOptions);
-        }
-    }
-}
-exports.Project = Project;
-Project.importRegex = new RegExp('^import "[^"./]+/[^"]*[a-z][a-z_0-9]*(.ral)?"', 'mg');
-Project.abstractContractMatcher = new TypedMatcher('^Abstract Contract ([A-Z][a-zA-Z0-9]*)', SourceKind.AbstractContract);
-Project.contractMatcher = new TypedMatcher('^Contract ([A-Z][a-zA-Z0-9]*)', SourceKind.Contract);
-Project.interfaceMatcher = new TypedMatcher('^Interface ([A-Z][a-zA-Z0-9]*)', SourceKind.Interface);
-Project.scriptMatcher = new TypedMatcher('^TxScript ([A-Z][a-zA-Z0-9]*)', SourceKind.Script);
-Project.matchers = [
-    Project.abstractContractMatcher,
-    Project.contractMatcher,
-    Project.interfaceMatcher,
-    Project.scriptMatcher
-];
-Project.DEFAULT_CONTRACTS_DIR = 'contracts';
-Project.DEFAULT_ARTIFACTS_DIR = 'artifacts';
-class Artifact {
-    constructor(version, name, functions) {
-        this.version = version;
-        this.name = name;
-        this.functions = functions;
-    }
-    publicFunctions() {
-        return this.functions.filter((func) => func.isPublic).map((func) => func.name);
-    }
-    usingPreapprovedAssetsFunctions() {
-        return this.functions.filter((func) => func.usePreapprovedAssets).map((func) => func.name);
-    }
-    usingAssetsInContractFunctions() {
-        return this.functions.filter((func) => func.useAssetsInContract).map((func) => func.name);
-    }
-}
-exports.Artifact = Artifact;
-class Contract extends Artifact {
-    constructor(version, name, bytecode, bytecodeDebugPatch, codeHash, codeHashDebug, fieldsSig, eventsSig, functions) {
-        super(version, name, functions);
-        this.bytecode = bytecode;
-        this.bytecodeDebugPatch = bytecodeDebugPatch;
-        this.codeHash = codeHash;
-        this.fieldsSig = fieldsSig;
-        this.eventsSig = eventsSig;
-        this.bytecodeDebug = ralph.buildDebugBytecode(this.bytecode, this.bytecodeDebugPatch);
-        this.codeHashDebug = codeHashDebug;
-    }
-    // TODO: safely parse json
-    static fromJson(artifact, bytecodeDebugPatch = '', codeHashDebug = '') {
-        if (artifact.version == null ||
-            artifact.name == null ||
-            artifact.bytecode == null ||
-            artifact.codeHash == null ||
-            artifact.fieldsSig == null ||
-            artifact.eventsSig == 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);
-        return contract;
-    }
-    static fromCompileResult(result) {
-        return new Contract(result.version, result.name, result.bytecode, result.bytecodeDebugPatch, result.codeHash, result.codeHashDebug, result.fields, result.events, result.functions);
-    }
-    // support both 'code.ral' and 'code.ral.json'
-    static async fromArtifactFile(path, bytecodeDebugPatch, codeHashDebug) {
-        const content = await fs_2.promises.readFile(path);
-        const artifact = JSON.parse(content.toString());
-        return Contract.fromJson(artifact, bytecodeDebugPatch, codeHashDebug);
-    }
-    toString() {
-        const object = {
-            version: this.version,
-            name: this.name,
-            bytecode: this.bytecode,
-            codeHash: this.codeHash,
-            fieldsSig: this.fieldsSig,
-            eventsSig: this.eventsSig,
-            functions: this.functions
-        };
-        return JSON.stringify(object, null, 2);
-    }
-    toState(fields, asset, address) {
-        const addressDef = typeof address !== 'undefined' ? address : Contract.randomAddress();
-        return {
-            address: addressDef,
-            contractId: (0, utils_1.binToHex)((0, utils_1.contractIdFromAddress)(addressDef)),
-            bytecode: this.bytecode,
-            codeHash: this.codeHash,
-            fields: fields,
-            fieldsSig: this.fieldsSig,
-            asset: asset
-        };
-    }
-    // no need to be cryptographically strong random
-    static randomAddress() {
-        const bytes = new Uint8Array(33);
-        crypto_1.webcrypto.getRandomValues(bytes);
-        bytes[0] = 3;
-        return utils_1.bs58.encode(bytes);
-    }
-    printDebugMessages(funcName, messages) {
-        if (messages.length != 0) {
-            console.log(`Testing ${this.name}.${funcName}:`);
-            messages.forEach((m) => console.log(`Debug - ${m.contractAddress} - ${m.message}`));
-        }
-    }
-    toApiFields(fields) {
-        if (typeof fields === 'undefined') {
-            return [];
-        }
-        else {
-            return toApiFields(fields, this.fieldsSig);
-        }
-    }
-    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);
-        }
-        else {
-            return [];
-        }
-    }
-    getMethodIndex(funcName) {
-        return this.functions.findIndex((func) => func.name === funcName);
-    }
-    toApiContractStates(states) {
-        return typeof states != 'undefined' ? states.map((state) => toApiContractState(state)) : undefined;
-    }
-    toApiTestContractParams(funcName, params) {
-        const immFields = params.initialFields === undefined ? [] : extractFields(params.initialFields, this.fieldsSig, false);
-        const mutFields = params.initialFields === undefined ? [] : extractFields(params.initialFields, this.fieldsSig, true);
-        return {
-            group: params.group,
-            blockHash: params.blockHash,
-            blockTimeStamp: params.blockTimeStamp,
-            txId: params.txId,
-            address: params.address,
-            bytecode: this.bytecodeDebug,
-            initialImmFields: immFields,
-            initialMutFields: mutFields,
-            initialAsset: typeof params.initialAsset !== 'undefined' ? toApiAsset(params.initialAsset) : undefined,
-            methodIndex: this.getMethodIndex(funcName),
-            args: this.toApiArgs(funcName, params.testArgs),
-            existingContracts: this.toApiContractStates(params.existingContracts),
-            inputAssets: toApiInputAssets(params.inputAssets)
-        };
-    }
-    fromApiContractState(state) {
-        return {
-            address: state.address,
-            contractId: (0, utils_1.binToHex)((0, utils_1.contractIdFromAddress)(state.address)),
-            bytecode: state.bytecode,
-            initialStateHash: state.initialStateHash,
-            codeHash: state.codeHash,
-            fields: fromApiFields(state.immFields, state.mutFields, this.fieldsSig),
-            fieldsSig: this.fieldsSig,
-            asset: fromApiAsset(state.asset)
-        };
-    }
-    static fromApiContractState(state) {
-        const contract = Project.currentProject.contractByCodeHash(state.codeHash);
-        return contract.fromApiContractState(state);
-    }
-    static fromApiEvent(event, codeHash, txId) {
-        let fields;
-        let name;
-        if (event.eventIndex == Contract.ContractCreatedEventIndex) {
-            fields = fromApiSystemEventFields(event.fields, Contract.ContractCreatedEvent);
-            name = Contract.ContractCreatedEvent.name;
-        }
-        else if (event.eventIndex == Contract.ContractDestroyedEventIndex) {
-            fields = fromApiSystemEventFields(event.fields, Contract.ContractDestroyedEvent);
-            name = Contract.ContractDestroyedEvent.name;
-        }
-        else {
-            const contract = Project.currentProject.contractByCodeHash(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) {
-        const methodIndex = this.functions.findIndex((sig) => sig.name === methodName);
-        const returnTypes = this.functions[`${methodIndex}`].returnTypes;
-        const rawReturn = (0, api_1.fromApiArray)(result.returns, returnTypes);
-        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: (0, utils_1.binToHex)((0, utils_1.contractIdFromAddress)(result.address)),
-            contractAddress: result.address,
-            returns: returns,
-            gasUsed: result.gasUsed,
-            contracts: result.contracts.map((contract) => Contract.fromApiContractState(contract)),
-            txOutputs: result.txOutputs.map(fromApiOutput),
-            events: Contract.fromApiEvents(result.events, addressToCodeHash, txId),
-            debugMessages: result.debugMessages
-        };
-    }
-    async txParamsForDeployment(signer, params) {
-        const bytecode = this.buildByteCodeToDeploy(params.initialFields ?? {});
-        const selectedAccount = await signer.getSelectedAccount();
-        const signerParams = {
-            signerAddress: selectedAccount.address,
-            signerKeyType: selectedAccount.keyType,
-            bytecode: bytecode,
-            initialAttoAlphAmount: params?.initialAttoAlphAmount,
-            issueTokenAmount: params?.issueTokenAmount,
-            initialTokenAmounts: params?.initialTokenAmounts,
-            gasAmount: params?.gasAmount,
-            gasPrice: params?.gasPrice
-        };
-        return signerParams;
-    }
-    buildByteCodeToDeploy(initialFields) {
-        return ralph.buildContractByteCode(this.bytecode, initialFields, this.fieldsSig);
-    }
-    static fromApiEvents(events, addressToCodeHash, txId) {
-        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);
-            }
-            else {
-                throw Error(`Cannot find codeHash for the contract address: ${contractAddress}`);
-            }
-        });
-    }
-    toApiCallContract(params, groupIndex, contractAddress, methodIndex) {
-        const functionSig = this.functions[`${methodIndex}`];
-        const args = toApiVals(params.args ?? {}, functionSig.paramNames, functionSig.paramTypes);
-        return {
-            ...params,
-            group: groupIndex,
-            address: contractAddress,
-            methodIndex: methodIndex,
-            args: args
-        };
-    }
-    fromApiCallContractResult(result, txId, methodIndex) {
-        const returnTypes = this.functions[`${methodIndex}`].returnTypes;
-        const rawReturn = (0, api_1.fromApiArray)(result.returns, returnTypes);
-        const returns = rawReturn.length === 0 ? null : rawReturn.length === 1 ? rawReturn[0] : rawReturn;
-        const addressToCodeHash = new Map();
-        result.contracts.forEach((contract) => addressToCodeHash.set(contract.address, contract.codeHash));
-        return {
-            returns: returns,
-            gasUsed: result.gasUsed,
-            contracts: result.contracts.map((state) => Contract.fromApiContractState(state)),
-            txInputs: result.txInputs,
-            txOutputs: result.txOutputs.map((output) => fromApiOutput(output)),
-            events: Contract.fromApiEvents(result.events, addressToCodeHash, txId)
-        };
-    }
-}
-exports.Contract = Contract;
-Contract.ContractCreatedEventIndex = -1;
-Contract.ContractCreatedEvent = {
-    name: 'ContractCreated',
-    fieldNames: ['address'],
-    fieldTypes: ['Address'],
-    optionalFieldNames: ['parentAddress'],
-    optionalFieldTypes: ['Address']
-};
-Contract.ContractDestroyedEventIndex = -2;
-Contract.ContractDestroyedEvent = {
-    name: 'ContractDestroyed',
-    fieldNames: ['address'],
-    fieldTypes: ['Address']
-};
-class Script extends Artifact {
-    constructor(version, name, bytecodeTemplate, bytecodeDebugPatch, fieldsSig, functions) {
-        super(version, name, functions);
-        this.bytecodeTemplate = bytecodeTemplate;
-        this.bytecodeDebugPatch = bytecodeDebugPatch;
-        this.fieldsSig = fieldsSig;
-    }
-    static fromCompileResult(result) {
-        return new Script(result.version, result.name, result.bytecodeTemplate, result.bytecodeDebugPatch, result.fields, result.functions);
-    }
-    // TODO: safely parse json
-    static fromJson(artifact, bytecodeDebugPatch = '') {
-        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);
-    }
-    static async fromArtifactFile(path, bytecodeDebugPatch) {
-        const content = await fs_2.promises.readFile(path);
-        const artifact = JSON.parse(content.toString());
-        return this.fromJson(artifact, bytecodeDebugPatch);
-    }
-    toString() {
-        const object = {
-            version: this.version,
-            name: this.name,
-            bytecodeTemplate: this.bytecodeTemplate,
-            fieldsSig: this.fieldsSig,
-            functions: this.functions
-        };
-        return JSON.stringify(object, null, 2);
-    }
-    async txParamsForExecution(signer, params) {
-        const selectedAccount = await signer.getSelectedAccount();
-        const signerParams = {
-            signerAddress: selectedAccount.address,
-            signerKeyType: selectedAccount.keyType,
-            bytecode: this.buildByteCodeToDeploy(params.initialFields ?? {}),
-            attoAlphAmount: params.attoAlphAmount,
-            tokens: params.tokens,
-            gasAmount: params.gasAmount,
-            gasPrice: params.gasPrice
-        };
-        return signerParams;
-    }
-    buildByteCodeToDeploy(initialFields) {
-        return ralph.buildScriptByteCode(this.bytecodeTemplate, initialFields, this.fieldsSig);
-    }
-}
-exports.Script = Script;
-function fromApiFields(immFields, mutFields, fieldsSig) {
-    const vals = [];
-    let immIndex = 0;
-    let mutIndex = 0;
-    const isMutable = fieldsSig.types.flatMap((tpe, index) => Array((0, api_1.typeLength)(tpe)).fill(fieldsSig.isMutable[`${index}`]));
-    isMutable.forEach((mutable) => {
-        if (mutable) {
-            vals.push(mutFields[`${mutIndex}`]);
-            mutIndex += 1;
-        }
-        else {
-            vals.push(immFields[`${immIndex}`]);
-            immIndex += 1;
-        }
-    });
-    return (0, api_1.fromApiVals)(vals, fieldsSig.names, fieldsSig.types);
-}
-function fromApiEventFields(vals, eventSig) {
-    return (0, api_1.fromApiVals)(vals, eventSig.fieldNames, eventSig.fieldTypes);
-}
-function fromApiSystemEventFields(vals, systemEventSig) {
-    return (0, api_1.fromApiVals)(vals, systemEventSig.fieldNames, systemEventSig.fieldTypes, systemEventSig.optionalFieldNames ?? [], systemEventSig.optionalFieldTypes ?? []);
-}
-function toApiAsset(asset) {
-    return {
-        attoAlphAmount: (0, api_1.toApiNumber256)(asset.alphAmount),
-        tokens: typeof asset.tokens !== 'undefined' ? asset.tokens.map(api_1.toApiToken) : []
-    };
-}
-function fromApiAsset(asset) {
-    return {
-        alphAmount: (0, api_1.fromApiNumber256)(asset.attoAlphAmount),
-        tokens: (0, api_1.fromApiTokens)(asset.tokens)
-    };
-}
-function getVal(vals, name) {
-    if (name in vals) {
-        return vals[`${name}`];
-    }
-    else {
-        throw Error(`No Val exists for ${name}`);
-    }
-}
-function extractFields(fields, fieldsSig, mutable) {
-    const fieldIndexes = fieldsSig.names
-        .map((_, index) => index)
-        .filter((index) => fieldsSig.isMutable[`${index}`] === mutable);
-    const fieldNames = fieldIndexes.map((index) => fieldsSig.names[`${index}`]);
-    const fieldTypes = fieldIndexes.map((index) => fieldsSig.types[`${index}`]);
-    return toApiVals(fields, fieldNames, fieldTypes);
-}
-function toApiContractState(state) {
-    const stateFields = state.fields ?? {};
-    return {
-        address: state.address,
-        bytecode: state.bytecode,
-        codeHash: state.codeHash,
-        initialStateHash: state.initialStateHash,
-        immFields: extractFields(stateFields, state.fieldsSig, false),
-        mutFields: extractFields(stateFields, state.fieldsSig, true),
-        asset: toApiAsset(state.asset)
-    };
-}
-function toApiFields(fields, fieldsSig) {
-    return toApiVals(fields, fieldsSig.names, fieldsSig.types);
-}
-function toApiArgs(args, funcSig) {
-    return toApiVals(args, funcSig.paramNames, funcSig.paramTypes);
-}
-function toApiVals(fields, names, types) {
-    return names.map((name, index) => {
-        const val = getVal(fields, name);
-        const tpe = types[`${index}`];
-        return (0, api_1.toApiVal)(val, tpe);
-    });
-}
-exports.toApiVals = toApiVals;
-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: (0, api_1.fromApiNumber256)(asset.attoAlphAmount),
-            tokens: (0, api_1.fromApiTokens)(asset.tokens),
-            lockTime: asset.lockTime,
-            message: asset.message
-        };
-    }
-    else if (output.type === 'ContractOutput') {
-        const asset = output;
-        return {
-            type: 'ContractOutput',
-            address: asset.address,
-            alphAmount: (0, api_1.fromApiNumber256)(asset.attoAlphAmount),
-            tokens: (0, api_1.fromApiTokens)(asset.tokens)
-        };
-    }
-    else {
-        throw new Error(`Unknown output type: ${output}`);
-    }
-}
-function randomTxId() {
-    const bytes = new Uint8Array(32);
-    crypto_1.webcrypto.getRandomValues(bytes);
-    return (0, utils_1.binToHex)(bytes);
-}
-exports.randomTxId = randomTxId;
-utils_1.assertType;
-class ContractFactory {
-    constructor(contract) {
-        this.contract = contract;
-    }
-    async deploy(signer, deployParams) {
-        const signerParams = await this.contract.txParamsForDeployment(signer, deployParams);
-        const result = await signer.signAndSubmitDeployContractTx(signerParams);
-        return {
-            ...result,
-            instance: this.at(result.contractAddress)
-        };
-    }
-    // This is used for testing contract functions
-    stateForTest(initFields, asset, address) {
-        const newAsset = {
-            alphAmount: asset?.alphAmount ?? constants_1.ONE_ALPH,
-            tokens: asset?.tokens
-        };
-        return this.contract.toState(initFields, newAsset, address);
-    }
-}
-exports.ContractFactory = ContractFactory;
-function specialContractAddress(n) {
-    const bytes = new Uint8Array(32).fill(0);
-    bytes[31] = n;
-    return (0, utils_1.addressFromContractId)((0, utils_1.binToHex)(bytes));
-}
-exports.CreateContractEventAddress = specialContractAddress(-1);
-exports.DestroyContractEventAddress = specialContractAddress(-2);
-function decodeSystemEvent(event, systemEventSig, eventIndex) {
-    if (event.eventIndex !== eventIndex) {
-        throw new Error(`Invalid event index: ${event.eventIndex}, expected: ${eventIndex}`);
-    }
-    return fromApiSystemEventFields(event.fields, systemEventSig);
-}
-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: {
-            address: fields['address'],
-            parentAddress: fields['parentAddress'] === undefined ? undefined : fields['parentAddress']
-        }
-    };
-}
-exports.decodeContractCreatedEvent = decodeContractCreatedEvent;
-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'] }
-    };
-}
-exports.decodeContractDestroyedEvent = decodeContractDestroyedEvent;
-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
-    };
-    return (0, events_1.subscribeToEvents)(opt, address, fromCount);
-}
-exports.subscribeEventsFromContract = subscribeEventsFromContract;
-async function testMethod(contract, methodName, params) {
-    const txId = params?.txId ?? randomTxId();
-    const apiParams = contract.contract.toApiTestContractParams(methodName, {
-        ...params,
-        txId: txId,
-        initialFields: params.initialFields === undefined ? {} : params.initialFields,
-        testArgs: params.testArgs === undefined ? {} : params.testArgs
-    });
-    const apiResult = await (0, global_1.getCurrentNodeProvider)().contracts.postContractsTestContract(apiParams);
-    const testResult = contract.contract.fromApiTestContractResult(methodName, apiResult, txId);
-    contract.contract.printDebugMessages(methodName, testResult.debugMessages);
-    return testResult;
-}
-exports.testMethod = testMethod;
-class ContractInstance {
-    constructor(address) {
-        this.address = address;
-        this.contractId = (0, utils_1.binToHex)((0, utils_1.contractIdFromAddress)(address));
-        this.groupIndex = (0, utils_1.groupOfAddress)(address);
-    }
-}
-exports.ContractInstance = ContractInstance;
-async function fetchContractState(contract, instance) {
-    const contractState = await (0, global_1.getCurrentNodeProvider)().contracts.getContractsAddressState(instance.address, {
-        group: instance.groupIndex
-    });
-    const state = contract.contract.fromApiContractState(contractState);
-    return {
-        ...state,
-        fields: state.fields
-    };
-}
-exports.fetchContractState = fetchContractState;
-function subscribeContractCreatedEvent(options, fromCount) {
-    return subscribeEventsFromContract(options, exports.CreateContractEventAddress, Contract.ContractCreatedEventIndex, (event) => {
-        return {
-            ...decodeContractCreatedEvent(event),
-            contractAddress: exports.CreateContractEventAddress
-        };
-    }, fromCount);
-}
-exports.subscribeContractCreatedEvent = subscribeContractCreatedEvent;
-function subscribeContractDestroyedEvent(options, fromCount) {
-    return subscribeEventsFromContract(options, exports.DestroyContractEventAddress, Contract.ContractDestroyedEventIndex, (event) => {
-        return {
-            ...decodeContractDestroyedEvent(event),
-            contractAddress: exports.DestroyContractEventAddress
-        };
-    }, fromCount);
-}
-exports.subscribeContractDestroyedEvent = subscribeContractDestroyedEvent;
-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 fieldNames = eventSig.fieldNames;
-    const fieldTypes = eventSig.fieldTypes;
-    const fields = (0, api_1.fromApiVals)(event.fields, fieldNames, fieldTypes);
-    return {
-        contractAddress: instance.address,
-        blockHash: event.blockHash,
-        txId: event.txId,
-        eventIndex: event.eventIndex,
-        name: eventSig.name,
-        fields: fields
-    };
-}
-exports.decodeEvent = decodeEvent;
-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);
-}
-exports.subscribeContractEvent = subscribeContractEvent;
-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
-    };
-    return (0, events_1.subscribeToEvents)(opt, instance.address, fromCount);
-}
-exports.subscribeContractEvents = subscribeContractEvents;
-async function callMethod(contract, instance, methodName, params) {
-    const methodIndex = contract.contract.getMethodIndex(methodName);
-    const txId = params?.txId ?? randomTxId();
-    const callParams = contract.contract.toApiCallContract({ ...params, txId: txId, args: params.args === undefined ? {} : params.args }, instance.groupIndex, instance.address, methodIndex);
-    const result = await (0, global_1.getCurrentNodeProvider)().contracts.postContractsCallContract(callParams);
-    const callResult = contract.contract.fromApiCallContractResult(result, txId, methodIndex);
-    return callResult;
-}
-exports.callMethod = callMethod;
-async function multicallMethods(contract, instance, calls) {
-    const callEntries = Object.entries(calls);
-    const callsParams = callEntries.map((entry) => {
-        const [methodName, params] = entry;
-        const methodIndex = contract.contract.getMethodIndex(methodName);
-        const txId = params?.txId ?? randomTxId();
-        return contract.contract.toApiCallContract({ ...params, txId: txId, args: params.args === undefined ? {} : params.args }, instance.groupIndex, instance.address, methodIndex);
-    });
-    const result = await (0, global_1.getCurrentNodeProvider)().contracts.postContractsMulticallContract({ calls: callsParams });
-    const callsResult = {};
-    callsParams.forEach((call, index) => {
-        const methodIndex = call.methodIndex;
-        const callResult = result.results[`${methodIndex}`];
-        const methodName = callEntries[`${index}`][`0`];
-        callsResult[`${methodName}`] = contract.contract.fromApiCallContractResult(callResult, call.txId, methodIndex);
-    });
-    return callsResult;
-}
-exports.multicallMethods = multicallMethods;
-async function getContractEventsCurrentCount(contractAddress) {
-    return (0, global_1.getCurrentNodeProvider)()
-        .events.getEventsContractContractaddressCurrentCount(contractAddress)
-        .catch((error) => {
-        if (error instanceof Error && error.message.includes(`${contractAddress} not found`)) {
-            return 0;
-        }
-        throw error;
-    });
-}
-exports.getContractEventsCurrentCount = getContractEventsCurrentCount;