@alephium/web3 0.2.0-test.1 → 0.2.2

package/dist/src/contract/contract.js

@@ -18,7 +18,11 @@ 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;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[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];
@@ -39,15 +43,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.toApiVal = exports.extractArray = exports.Script = exports.Contract = exports.Artifact = exports.Project = exports.DEFAULT_COMPILER_OPTIONS = void 0;
+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 cryptojs = __importStar(require("crypto-js"));
-const crypto = __importStar(require("crypto"));
+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 __1 = require("..");
 var SourceType;
 (function (SourceType) {
     SourceType[SourceType["Contract"] = 0] = "Contract";
@@ -55,34 +60,38 @@ var SourceType;
     SourceType[SourceType["AbstractContract"] = 2] = "AbstractContract";
     SourceType[SourceType["Interface"] = 3] = "Interface";
 })(SourceType || (SourceType = {}));
-exports.DEFAULT_COMPILER_OPTIONS = {
-    errorOnWarnings: true,
-    ignoreUnusedConstantsWarnings: true
+exports.DEFAULT_NODE_COMPILER_OPTIONS = {
+    ignoreUnusedConstantsWarnings: false,
+    ignoreUnusedVariablesWarnings: false,
+    ignoreUnusedFieldsWarnings: false,
+    ignoreUnusedPrivateFunctionsWarnings: false,
+    ignoreUpdateFieldsCheckWarnings: false,
+    ignoreExternalCallCheckWarnings: 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;
-        this.name = undefined;
     }
     match(str) {
-        const results = [...str.matchAll(this.matcher)];
-        if (results.length > 0) {
-            this.name = results[0][1];
-        }
-        return results.length;
+        const results = str.match(this.matcher);
+        return results === null ? 0 : results.length;
     }
 }
 class SourceFile {
-    constructor(type, typeId, sourceCode, contractPath) {
+    constructor(type, sourceCode, sourceCodeHash, contractPath) {
         this.type = type;
-        this.typeId = typeId;
         this.sourceCode = sourceCode;
-        this.sourceCodeHash = cryptojs.SHA256(sourceCode).toString();
+        this.sourceCodeHash = sourceCodeHash;
         this.contractPath = contractPath;
     }
-    getArtifactPath(artifactsRootPath) {
-        return artifactsRootPath + this.contractPath.slice(this.contractPath.indexOf('/')) + '.json';
+    getArtifactPath(artifactsRootDir) {
+        return artifactsRootDir + this.contractPath.slice(this.contractPath.indexOf('/')) + '.json';
+    }
+    static async from(type, sourceCode, contractPath) {
+        const sourceCodeHash = await crypto_1.webcrypto.subtle.digest('SHA-256', buffer_1.Buffer.from(sourceCode));
+        return new SourceFile(type, sourceCode, buffer_1.Buffer.from(sourceCodeHash).toString('hex'), contractPath);
     }
 }
 class Compiled {
@@ -93,15 +102,35 @@ class Compiled {
     }
 }
 class ProjectArtifact {
-    constructor(infos) {
+    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 = rootPath + '/' + ProjectArtifact.artifactFileName;
-        const content = JSON.stringify(Object.fromEntries(this.infos), null, 2);
+        const artifact = { compilerOptionsUsed: this.compilerOptionsUsed, infos: Object.fromEntries(this.infos) };
+        const content = JSON.stringify(artifact, null, 2);
         return fs_2.promises.writeFile(filepath, content);
     }
-    sourceHasChanged(files) {
+    needToReCompile(compilerOptions, files) {
+        ProjectArtifact.checkCompilerOptionsParameter(compilerOptions);
+        const optionsMatched = Object.entries(compilerOptions).every(([key, inputOption]) => {
+            const usedOption = this.compilerOptionsUsed[`${key}`];
+            return usedOption === inputOption;
+        });
+        if (!optionsMatched) {
+            return true;
+        }
         if (files.length !== this.infos.size) {
             return true;
         }
@@ -119,36 +148,67 @@ class ProjectArtifact {
             return undefined;
         }
         const content = await fs_2.promises.readFile(filepath);
-        const files = new Map(Object.entries(JSON.parse(content.toString())));
-        return new ProjectArtifact(files);
+        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(provider, contractsRootPath, artifactsRootPath, sourceFiles, contracts, scripts) {
-        this.nodeProvider = provider;
-        this.contractsRootPath = contractsRootPath;
-        this.artifactsRootPath = artifactsRootPath;
+    constructor(contractsRootDir, artifactsRootDir, sourceFiles, contracts, scripts, errorOnWarnings, projectArtifact) {
+        this.contractsRootDir = contractsRootDir;
+        this.artifactsRootDir = artifactsRootDir;
         this.sourceFiles = sourceFiles;
         this.contracts = contracts;
         this.scripts = scripts;
+        this.projectArtifact = projectArtifact;
+        if (errorOnWarnings) {
+            Project.checkCompilerWarnings([...contracts.map((c) => c.warnings).flat(), ...scripts.map((s) => s.warnings).flat()], errorOnWarnings);
+        }
+    }
+    static buildProjectArtifact(sourceFiles, contracts, scripts, compilerOptions) {
+        const files = new Map();
+        contracts.forEach((c) => {
+            files.set(c.sourceFile.contractPath, {
+                sourceCodeHash: c.sourceFile.sourceCodeHash,
+                bytecodeDebugPatch: c.artifact.bytecodeDebugPatch,
+                codeHashDebug: c.artifact.codeHashDebug,
+                warnings: c.warnings
+            });
+        });
+        scripts.forEach((s) => {
+            files.set(s.sourceFile.contractPath, {
+                sourceCodeHash: s.sourceFile.sourceCodeHash,
+                bytecodeDebugPatch: s.artifact.bytecodeDebugPatch,
+                codeHashDebug: '',
+                warnings: s.warnings
+            });
+        });
+        const compiledSize = contracts.length + scripts.length;
+        sourceFiles.slice(compiledSize).forEach((c) => {
+            files.set(c.contractPath, {
+                sourceCodeHash: c.sourceCodeHash,
+                bytecodeDebugPatch: '',
+                codeHashDebug: '',
+                warnings: []
+            });
+        });
+        return new ProjectArtifact(compilerOptions, files);
     }
     getContractPath(path) {
-        return path.startsWith(`./${this.contractsRootPath}`)
+        return path.startsWith(`./${this.contractsRootDir}`)
             ? path.slice(2)
-            : path.startsWith(this.contractsRootPath)
+            : path.startsWith(this.contractsRootDir)
                 ? path
-                : this.contractsRootPath + '/' + path;
+                : this.contractsRootDir + '/' + path;
     }
-    static checkCompilerWarnings(warnings, compilerOptions) {
-        const remains = compilerOptions.ignoreUnusedConstantsWarnings
-            ? warnings.filter((s) => !s.includes('unused constants'))
-            : warnings;
-        if (remains.length !== 0) {
+    static checkCompilerWarnings(warnings, errorOnWarnings) {
+        if (warnings.length !== 0) {
             const prefixPerWarning = '  - ';
-            const warningString = prefixPerWarning + remains.join('\n' + prefixPerWarning);
-            const output = 'Compilation warnings:\n' + warningString + '\n';
-            if (compilerOptions.errorOnWarnings) {
+            const warningString = prefixPerWarning + warnings.join('\n' + prefixPerWarning);
+            const output = `Compilation warnings:\n` + warningString + '\n';
+            if (errorOnWarnings) {
                 throw new Error(output);
             }
             else {
@@ -156,95 +216,69 @@ class Project {
             }
         }
     }
-    static contract(path, compilerOptions) {
-        const contractPath = Project.currentProject.getContractPath(path);
-        const contract = Project.currentProject.contracts.find((c) => c.sourceFile.contractPath === contractPath);
+    static contract(name) {
+        const contract = Project.currentProject.contracts.find((c) => c.artifact.name === name);
         if (typeof contract === 'undefined') {
-            throw new Error(`Contract ${contractPath} does not exist`);
+            throw new Error(`Contract "${name}" does not exist`);
         }
-        Project.checkCompilerWarnings(contract.warnings, { ...exports.DEFAULT_COMPILER_OPTIONS, ...compilerOptions });
         return contract.artifact;
     }
-    static script(path, compilerOptions) {
-        const contractPath = Project.currentProject.getContractPath(path);
-        const script = Project.currentProject.scripts.find((c) => c.sourceFile.contractPath === contractPath);
+    static script(name) {
+        const script = Project.currentProject.scripts.find((c) => c.artifact.name === name);
         if (typeof script === 'undefined') {
-            throw new Error(`Script ${contractPath} does not exist`);
+            throw new Error(`Script "${name}" does not exist`);
         }
-        Project.checkCompilerWarnings(script.warnings, { ...exports.DEFAULT_COMPILER_OPTIONS, ...compilerOptions });
         return script.artifact;
     }
     async saveArtifactsToFile() {
-        const artifactsRootPath = this.artifactsRootPath;
+        const artifactsRootDir = this.artifactsRootDir;
         const saveToFile = async function (compiled) {
-            const artifactPath = compiled.sourceFile.getArtifactPath(artifactsRootPath);
-            const folder = artifactPath.slice(0, artifactPath.lastIndexOf('/'));
+            const artifactDir = compiled.sourceFile.getArtifactPath(artifactsRootDir);
+            const folder = artifactDir.slice(0, artifactDir.lastIndexOf('/'));
             if (!fs_1.default.existsSync(folder)) {
                 fs_1.default.mkdirSync(folder, { recursive: true });
             }
-            return fs_2.promises.writeFile(artifactPath, compiled.artifact.toString());
+            return fs_2.promises.writeFile(artifactDir, compiled.artifact.toString());
         };
         for (const contract of this.contracts) {
-            await saveToFile(contract);
+            saveToFile(contract);
         }
         for (const script of this.scripts) {
             await saveToFile(script);
         }
+        await this.projectArtifact.saveToFile(this.artifactsRootDir);
     }
     contractByCodeHash(codeHash) {
-        const contract = this.contracts.find((c) => c.artifact.codeHash === codeHash);
+        const contract = this.contracts.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;
     }
-    async saveProjectArtifactToFile() {
-        const files = new Map();
-        this.contracts.forEach((c) => {
-            files.set(c.sourceFile.contractPath, {
-                sourceCodeHash: c.sourceFile.sourceCodeHash,
-                warnings: c.warnings
-            });
-        });
-        this.scripts.forEach((s) => {
-            files.set(s.sourceFile.contractPath, {
-                sourceCodeHash: s.sourceFile.sourceCodeHash,
-                warnings: s.warnings
-            });
-        });
-        const compiledSize = this.contracts.length + this.scripts.length;
-        this.sourceFiles.slice(compiledSize).forEach((c) => {
-            files.set(c.contractPath, {
-                sourceCodeHash: c.sourceCodeHash,
-                warnings: []
-            });
-        });
-        const projectArtifact = new ProjectArtifact(files);
-        await projectArtifact.saveToFile(this.artifactsRootPath);
-    }
-    static async compile(provider, files, contractsRootPath, artifactsRootPath) {
+    static async compile(provider, files, contractsRootDir, artifactsRootDir, errorOnWarnings, compilerOptions) {
         const sourceStr = files.map((f) => f.sourceCode).join('\n');
         const result = await provider.contracts.postContractsCompileProject({
-            code: sourceStr
+            code: sourceStr,
+            compilerOptions: compilerOptions
         });
         const contracts = [];
         const scripts = [];
         result.contracts.forEach((contractResult, index) => {
             const sourceFile = files[`${index}`];
-            const contract = Contract.fromCompileResult(sourceFile.typeId, contractResult);
+            const contract = Contract.fromCompileResult(contractResult);
             contracts.push(new Compiled(sourceFile, contract, contractResult.warnings));
         });
         result.scripts.forEach((scriptResult, index) => {
             const sourceFile = files[index + contracts.length];
-            const script = Script.fromCompileResult(sourceFile.typeId, scriptResult);
+            const script = Script.fromCompileResult(scriptResult);
             scripts.push(new Compiled(sourceFile, script, scriptResult.warnings));
         });
-        const project = new Project(provider, contractsRootPath, artifactsRootPath, files, contracts, scripts);
+        const projectArtifact = Project.buildProjectArtifact(files, contracts, scripts, compilerOptions);
+        const project = new Project(contractsRootDir, artifactsRootDir, files, contracts, scripts, errorOnWarnings, projectArtifact);
         await project.saveArtifactsToFile();
-        await project.saveProjectArtifactToFile();
         return project;
     }
-    static async loadArtifacts(provider, files, projectArtifact, contractsRootPath, artifactsRootPath) {
+    static async loadArtifacts(provider, files, projectArtifact, contractsRootDir, artifactsRootDir, errorOnWarnings, compilerOptions) {
         try {
             const contracts = [];
             const scripts = [];
@@ -254,21 +288,21 @@ class Project {
                     throw Error(`Unable to find project info for ${file.contractPath}, please rebuild the project`);
                 }
                 const warnings = info.warnings;
-                const artifactPath = file.getArtifactPath(artifactsRootPath);
+                const artifactDir = file.getArtifactPath(artifactsRootDir);
                 if (file.type === SourceType.Contract) {
-                    const artifact = await Contract.fromArtifactFile(artifactPath);
+                    const artifact = await Contract.fromArtifactFile(artifactDir, info.bytecodeDebugPatch, info.codeHashDebug);
                     contracts.push(new Compiled(file, artifact, warnings));
                 }
                 else if (file.type === SourceType.Script) {
-                    const artifact = await Script.fromArtifactFile(artifactPath);
+                    const artifact = await Script.fromArtifactFile(artifactDir, info.bytecodeDebugPatch);
                     scripts.push(new Compiled(file, artifact, warnings));
                 }
             }
-            return new Project(provider, contractsRootPath, artifactsRootPath, files, contracts, scripts);
+            return new Project(contractsRootDir, artifactsRootDir, files, contracts, scripts, errorOnWarnings, projectArtifact);
         }
         catch (error) {
             console.log(`Failed to load artifacts, error: ${error}, try to re-compile contracts...`);
-            return Project.compile(provider, files, contractsRootPath, artifactsRootPath);
+            return Project.compile(provider, files, contractsRootDir, artifactsRootDir, errorOnWarnings, compilerOptions);
         }
     }
     static async loadSourceFile(dirPath, filename) {
@@ -287,14 +321,10 @@ class Project {
             throw new Error(`Multiple definitions in file: ${contractPath}`);
         }
         const matcherIndex = results.indexOf(1);
-        const matcher = this.matchers[`${matcherIndex}`];
-        const type = matcher.type;
-        if (matcher.name === undefined) {
-            throw new Error(`Invalid definition in file: ${contractPath}`);
-        }
-        return new SourceFile(type, matcher.name, sourceStr, contractPath);
+        const type = this.matchers[`${matcherIndex}`].type;
+        return SourceFile.from(type, sourceStr, contractPath);
     }
-    static async loadSourceFiles(contractsRootPath) {
+    static async loadSourceFiles(contractsRootDir) {
         const loadDir = async function (dirPath, results) {
             const dirents = await fs_2.promises.readdir(dirPath, { withFileTypes: true });
             for (const dirent of dirents) {
@@ -309,39 +339,45 @@ class Project {
             }
         };
         const sourceFiles = [];
-        await loadDir(contractsRootPath, sourceFiles);
+        await loadDir(contractsRootDir, sourceFiles);
         const contractAndScriptSize = sourceFiles.filter((f) => f.type === SourceType.Contract || f.type === SourceType.Script).length;
         if (sourceFiles.length === 0 || contractAndScriptSize === 0) {
             throw new Error('Project have no source files');
         }
         return sourceFiles.sort((a, b) => a.type - b.type);
     }
-    static async build(contractsRootPath = 'contracts', artifactsRootPath = 'artifacts') {
+    static async build(compilerOptionsPartial = {}, contractsRootDir = Project.DEFAULT_CONTRACTS_DIR, artifactsRootDir = Project.DEFAULT_ARTIFACTS_DIR) {
         const provider = (0, global_1.getCurrentNodeProvider)();
-        const sourceFiles = await Project.loadSourceFiles(contractsRootPath);
-        const projectArtifact = await ProjectArtifact.from(artifactsRootPath);
-        if (typeof projectArtifact === 'undefined' || projectArtifact.sourceHasChanged(sourceFiles)) {
-            Project.currentProject = await Project.compile(provider, sourceFiles, contractsRootPath, artifactsRootPath);
+        const sourceFiles = await Project.loadSourceFiles(contractsRootDir);
+        const { errorOnWarnings, ...nodeCompilerOptions } = { ...exports.DEFAULT_COMPILER_OPTIONS, ...compilerOptionsPartial };
+        const projectArtifact = await ProjectArtifact.from(artifactsRootDir);
+        if (typeof projectArtifact === 'undefined' || projectArtifact.needToReCompile(nodeCompilerOptions, sourceFiles)) {
+            console.log(`Compiling contracts in folder "${contractsRootDir}"`);
+            Project.currentProject = await Project.compile(provider, sourceFiles, contractsRootDir, artifactsRootDir, errorOnWarnings, nodeCompilerOptions);
         }
         else {
-            Project.currentProject = await Project.loadArtifacts(provider, sourceFiles, projectArtifact, contractsRootPath, artifactsRootPath);
+            console.log(`Contracts are compiled already. Loading them from folder "${artifactsRootDir}"`);
+            Project.currentProject = await Project.loadArtifacts(provider, sourceFiles, projectArtifact, contractsRootDir, artifactsRootDir, errorOnWarnings, nodeCompilerOptions);
         }
     }
 }
 exports.Project = Project;
-Project.abstractContractMatcher = new TypedMatcher('^Abstract Contract ([A-Z][a-zA-Z0-9]*)\\(*', SourceType.AbstractContract);
-Project.contractMatcher = new TypedMatcher('^Contract ([A-Z][a-zA-Z0-9]*)\\(*', SourceType.Contract);
-Project.interfaceMatcher = new TypedMatcher('^Interface ([A-Z][a-zA-Z0-9]*) \\{', SourceType.Interface);
-Project.scriptMatcher = new TypedMatcher('^TxScript ([A-Z][a-zA-Z0-9]*)( \\{*|\\(*)', SourceType.Script);
+Project.abstractContractMatcher = new TypedMatcher('^Abstract Contract [A-Z][a-zA-Z0-9]*', SourceType.AbstractContract);
+Project.contractMatcher = new TypedMatcher('^Contract [A-Z][a-zA-Z0-9]*', SourceType.Contract);
+Project.interfaceMatcher = new TypedMatcher('^Interface [A-Z][a-zA-Z0-9]* \\{', SourceType.Interface);
+Project.scriptMatcher = new TypedMatcher('^TxScript [A-Z][a-zA-Z0-9]*', SourceType.Script);
 Project.matchers = [
     Project.abstractContractMatcher,
     Project.contractMatcher,
     Project.interfaceMatcher,
     Project.scriptMatcher
 ];
+Project.DEFAULT_CONTRACTS_DIR = 'contracts';
+Project.DEFAULT_ARTIFACTS_DIR = 'artifacts';
 class Artifact {
-    constructor(typeId, functions) {
-        this.typeId = typeId;
+    constructor(version, name, functions) {
+        this.version = version;
+        this.name = name;
         this.functions = functions;
     }
     publicFunctions() {
@@ -356,43 +392,49 @@ class Artifact {
 }
 exports.Artifact = Artifact;
 class Contract extends Artifact {
-    constructor(typeId, bytecode, codeHash, fieldsSig, eventsSig, functions) {
-        super(typeId, functions);
+    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) {
-        if (artifact.bytecode == null ||
+    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.typeId, artifact.bytecode, artifact.codeHash, artifact.fieldsSig, artifact.eventsSig, artifact.functions);
+        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(typeId, result) {
-        return new Contract(typeId, result.bytecode, result.codeHash, result.fields, result.events, result.functions);
+    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) {
+    static async fromArtifactFile(path, bytecodeDebugPatch, codeHashDebug) {
         const content = await fs_2.promises.readFile(path);
         const artifact = JSON.parse(content.toString());
-        return Contract.fromJson(artifact);
+        return Contract.fromJson(artifact, bytecodeDebugPatch, codeHashDebug);
     }
     async fetchState(address, group) {
-        const state = await Project.currentProject.nodeProvider.contracts.getContractsAddressState(address, {
+        const state = await __1.web3.getCurrentNodeProvider().contracts.getContractsAddressState(address, {
             group: group
         });
         return this.fromApiContractState(state);
     }
     toString() {
         const object = {
-            typeId: this.typeId,
+            version: this.version,
+            name: this.name,
             bytecode: this.bytecode,
             codeHash: this.codeHash,
             fieldsSig: this.fieldsSig,
@@ -413,16 +455,27 @@ class Contract extends Artifact {
             asset: asset
         };
     }
+    // no need to be cryptographically strong random
     static randomAddress() {
-        const bytes = crypto.randomBytes(33);
+        const bytes = new Uint8Array(33);
+        crypto_1.webcrypto.getRandomValues(bytes);
         bytes[0] = 3;
         return utils_1.bs58.encode(bytes);
     }
-    async _test(funcName, params, expectPublic, accessType) {
+    _printDebugMessages(funcName, messages) {
+        if (messages.length != 0) {
+            console.log(`Testing ${this.name}.${funcName}:`);
+            messages.forEach((m) => console.log(`Debug - ${m.contractAddress} - ${m.message}`));
+        }
+    }
+    async _test(funcName, params, expectPublic, accessType, printDebugMessages) {
         const apiParams = this.toTestContract(funcName, params);
-        const apiResult = await Project.currentProject.nodeProvider.contracts.postContractsTestContract(apiParams);
+        const apiResult = await __1.web3.getCurrentNodeProvider().contracts.postContractsTestContract(apiParams);
         const methodIndex = typeof params.testMethodIndex !== 'undefined' ? params.testMethodIndex : this.getMethodIndex(funcName);
         const isPublic = this.functions[`${methodIndex}`].isPublic;
+        if (printDebugMessages) {
+            this._printDebugMessages(funcName, apiResult.debugMessages);
+        }
         if (isPublic === expectPublic) {
             const result = await this.fromTestContractResult(methodIndex, apiResult);
             return result;
@@ -431,11 +484,11 @@ class Contract extends Artifact {
             throw new Error(`The test method ${funcName} is not ${accessType}`);
         }
     }
-    async testPublicMethod(funcName, params) {
-        return this._test(funcName, params, true, 'public');
+    async testPublicMethod(funcName, params, printDebugMessages = true) {
+        return this._test(funcName, params, true, 'public', printDebugMessages);
     }
-    async testPrivateMethod(funcName, params) {
-        return this._test(funcName, params, false, 'private');
+    async testPrivateMethod(funcName, params, printDebugMessages = true) {
+        return this._test(funcName, params, false, 'private', printDebugMessages);
     }
     toApiFields(fields) {
         if (typeof fields === 'undefined') {
@@ -467,7 +520,7 @@ class Contract extends Artifact {
         return {
             group: params.group,
             address: params.address,
-            bytecode: this.bytecode,
+            bytecode: this.bytecodeDebug,
             initialFields: this.toApiFields(params.initialFields),
             initialAsset: typeof params.initialAsset !== 'undefined' ? toApiAsset(params.initialAsset) : undefined,
             methodIndex: this.getMethodIndex(funcName),
@@ -476,20 +529,23 @@ class Contract extends Artifact {
             inputAssets: toApiInputAssets(params.inputAssets)
         };
     }
-    async fromApiContractState(state) {
-        const contract = Project.currentProject.contractByCodeHash(state.codeHash);
+    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.fields, contract.fieldsSig),
-            fieldsSig: contract.fieldsSig,
+            fields: fromApiFields(state.fields, this.fieldsSig),
+            fieldsSig: this.fieldsSig,
             asset: fromApiAsset(state.asset)
         };
     }
-    static async fromApiEvent(event, codeHash) {
+    static fromApiContractState(state) {
+        const contract = Project.currentProject.contractByCodeHash(state.codeHash);
+        return contract.fromApiContractState(state);
+    }
+    static fromApiEvent(event, codeHash) {
         let eventSig;
         if (event.eventIndex == -1) {
             eventSig = this.ContractCreatedEvent;
@@ -508,18 +564,18 @@ class Contract extends Artifact {
             fields: fromApiEventFields(event.fields, eventSig)
         };
     }
-    async fromTestContractResult(methodIndex, result) {
+    fromTestContractResult(methodIndex, result) {
         const addressToCodeHash = new Map();
         addressToCodeHash.set(result.address, result.codeHash);
         result.contracts.forEach((contract) => addressToCodeHash.set(contract.address, contract.codeHash));
         return {
-            address: result.address,
             contractId: (0, utils_1.binToHex)((0, utils_1.contractIdFromAddress)(result.address)),
-            returns: fromApiArray(result.returns, this.functions[`${methodIndex}`].returnTypes),
+            contractAddress: result.address,
+            returns: (0, api_1.fromApiArray)(result.returns, this.functions[`${methodIndex}`].returnTypes),
             gasUsed: result.gasUsed,
-            contracts: await Promise.all(result.contracts.map((contract) => this.fromApiContractState(contract))),
+            contracts: result.contracts.map((contract) => Contract.fromApiContractState(contract)),
             txOutputs: result.txOutputs.map(fromApiOutput),
-            events: await Promise.all(result.events.map((event) => {
+            events: result.events.map((event) => {
                 const contractAddress = event.contractAddress;
                 const codeHash = addressToCodeHash.get(contractAddress);
                 if (typeof codeHash !== 'undefined' || event.eventIndex < 0) {
@@ -528,29 +584,26 @@ class Contract extends Artifact {
                 else {
                     throw Error(`Cannot find codeHash for the contract address: ${contractAddress}`);
                 }
-            }))
+            }),
+            debugMessages: result.debugMessages
         };
     }
-    async paramsForDeployment(params) {
+    async txParamsForDeployment(signer, params) {
         const bytecode = this.buildByteCodeToDeploy(params.initialFields ? params.initialFields : {});
         const signerParams = {
-            signerAddress: params.signerAddress,
+            signerAddress: (await signer.getSelectedAccount()).address,
             bytecode: bytecode,
-            initialAttoAlphAmount: extractOptionalNumber256(params.initialAttoAlphAmount),
-            issueTokenAmount: extractOptionalNumber256(params.issueTokenAmount),
-            initialTokenAmounts: params.initialTokenAmounts?.map(toApiToken),
+            initialAttoAlphAmount: params.initialAttoAlphAmount,
+            issueTokenAmount: params.issueTokenAmount,
+            initialTokenAmounts: params.initialTokenAmounts,
             gasAmount: params.gasAmount,
-            gasPrice: extractOptionalNumber256(params.gasPrice)
+            gasPrice: params.gasPrice
         };
         return signerParams;
     }
-    async transactionForDeployment(signer, params) {
-        const signerParams = await this.paramsForDeployment({
-            ...params,
-            signerAddress: (await signer.getAccounts())[0].address
-        });
-        const response = await signer.buildContractCreationTx(signerParams);
-        return fromApiDeployContractUnsignedTx(response);
+    async deploy(signer, params) {
+        const signerParams = await this.txParamsForDeployment(signer, params);
+        return signer.signAndSubmitDeployContractTx(signerParams);
     }
     buildByteCodeToDeploy(initialFields) {
         return ralph.buildContractByteCode(this.bytecode, initialFields, this.fieldsSig);
@@ -568,273 +621,77 @@ Contract.ContractDestroyedEvent = {
     fieldTypes: ['Address']
 };
 class Script extends Artifact {
-    constructor(typeId, bytecodeTemplate, fieldsSig, functions) {
-        super(typeId, functions);
+    constructor(version, name, bytecodeTemplate, bytecodeDebugPatch, fieldsSig, functions) {
+        super(version, name, functions);
         this.bytecodeTemplate = bytecodeTemplate;
+        this.bytecodeDebugPatch = bytecodeDebugPatch;
         this.fieldsSig = fieldsSig;
     }
-    static fromCompileResult(typeId, result) {
-        return new Script(typeId, result.bytecodeTemplate, result.fields, result.functions);
+    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) {
-        if (artifact.bytecodeTemplate == null || artifact.fieldsSig == null || artifact.functions == null) {
+    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.typeId, artifact.bytecodeTemplate, artifact.fieldsSig, artifact.functions);
+        return new Script(artifact.version, artifact.name, artifact.bytecodeTemplate, bytecodeDebugPatch, artifact.fieldsSig, artifact.functions);
     }
-    static async fromArtifactFile(path) {
+    static async fromArtifactFile(path, bytecodeDebugPatch) {
         const content = await fs_2.promises.readFile(path);
         const artifact = JSON.parse(content.toString());
-        return this.fromJson(artifact);
+        return this.fromJson(artifact, bytecodeDebugPatch);
     }
     toString() {
         const object = {
-            typeId: this.typeId,
+            version: this.version,
+            name: this.name,
             bytecodeTemplate: this.bytecodeTemplate,
             fieldsSig: this.fieldsSig,
             functions: this.functions
         };
         return JSON.stringify(object, null, 2);
     }
-    async paramsForDeployment(params) {
+    async txParamsForExecution(signer, params) {
         const signerParams = {
-            signerAddress: params.signerAddress,
+            signerAddress: (await signer.getSelectedAccount()).address,
             bytecode: this.buildByteCodeToDeploy(params.initialFields ? params.initialFields : {}),
-            attoAlphAmount: extractOptionalNumber256(params.attoAlphAmount),
-            tokens: typeof params.tokens !== 'undefined' ? params.tokens.map(toApiToken) : undefined,
+            attoAlphAmount: params.attoAlphAmount,
+            tokens: params.tokens,
             gasAmount: params.gasAmount,
-            gasPrice: extractOptionalNumber256(params.gasPrice)
+            gasPrice: params.gasPrice
         };
         return signerParams;
     }
-    async transactionForDeployment(signer, params) {
-        const signerParams = await this.paramsForDeployment({
-            ...params,
-            signerAddress: (await signer.getAccounts())[0].address
-        });
-        return await signer.buildScriptTx(signerParams);
+    async execute(signer, params) {
+        const signerParams = await this.txParamsForExecution(signer, params);
+        return await signer.signAndSubmitExecuteScriptTx(signerParams);
     }
     buildByteCodeToDeploy(initialFields) {
         return ralph.buildScriptByteCode(this.bytecodeTemplate, initialFields, this.fieldsSig);
     }
 }
 exports.Script = Script;
-function extractBoolean(v) {
-    if (typeof v === 'boolean') {
-        return v;
-    }
-    else {
-        throw new Error(`Invalid boolean value: ${v}`);
-    }
-}
-// TODO: check integer bounds
-function extractNumber256(v) {
-    if ((typeof v === 'number' && Number.isInteger(v)) || typeof v === 'bigint') {
-        return v.toString();
-    }
-    else if (typeof v === 'string') {
-        return v;
-    }
-    else {
-        throw new Error(`Invalid 256 bit number: ${v}`);
-    }
-}
-function extractOptionalNumber256(v) {
-    return typeof v !== 'undefined' ? extractNumber256(v) : undefined;
-}
-// TODO: check hex string
-function extractByteVec(v) {
-    if (typeof v === 'string') {
-        // try to convert from address to contract id
-        try {
-            const address = utils_1.bs58.decode(v);
-            if (address.length == 33 && address[0] == 3) {
-                return buffer_1.Buffer.from(address.slice(1)).toString('hex');
-            }
-        }
-        catch (_) {
-            return v;
-        }
-        return v;
-    }
-    else {
-        throw new Error(`Invalid string: ${v}`);
-    }
-}
-function extractBs58(v) {
-    if (typeof v === 'string') {
-        try {
-            utils_1.bs58.decode(v);
-            return v;
-        }
-        catch (error) {
-            throw new Error(`Invalid base58 string: ${v}`);
-        }
-    }
-    else {
-        throw new Error(`Invalid string: ${v}`);
-    }
-}
-function decodeNumber256(n) {
-    if (Number.isSafeInteger(Number.parseInt(n))) {
-        return Number(n);
-    }
-    else {
-        return BigInt(n);
-    }
-}
-function extractArray(tpe, v) {
-    if (!Array.isArray(v)) {
-        throw new Error(`Expected array, got ${v}`);
-    }
-    const semiColonIndex = tpe.lastIndexOf(';');
-    if (semiColonIndex == -1) {
-        throw new Error(`Invalid Val type: ${tpe}`);
-    }
-    const subType = tpe.slice(1, semiColonIndex);
-    const dim = parseInt(tpe.slice(semiColonIndex + 1, -1));
-    if (v.length != dim) {
-        throw new Error(`Invalid val dimension: ${v}`);
-    }
-    else {
-        return { value: v.map((v) => toApiVal(v, subType)), type: 'Array' };
-    }
-}
-exports.extractArray = extractArray;
-function toApiVal(v, tpe) {
-    if (tpe === 'Bool') {
-        return { value: extractBoolean(v), type: tpe };
-    }
-    else if (tpe === 'U256' || tpe === 'I256') {
-        return { value: extractNumber256(v), type: tpe };
-    }
-    else if (tpe === 'ByteVec') {
-        return { value: extractByteVec(v), type: tpe };
-    }
-    else if (tpe === 'Address') {
-        return { value: extractBs58(v), type: tpe };
-    }
-    else {
-        return extractArray(tpe, v);
-    }
-}
-exports.toApiVal = toApiVal;
-function decodeArrayType(tpe) {
-    const semiColonIndex = tpe.lastIndexOf(';');
-    if (semiColonIndex === -1) {
-        throw new Error(`Invalid Val type: ${tpe}`);
-    }
-    const subType = tpe.slice(1, semiColonIndex);
-    const dim = parseInt(tpe.slice(semiColonIndex + 1, -1));
-    if (subType[0] == '[') {
-        const [baseType, subDim] = decodeArrayType(subType);
-        return [baseType, (subDim.unshift(dim), subDim)];
-    }
-    else {
-        return [subType, [dim]];
-    }
-}
-function foldVals(vals, dims) {
-    if (dims.length == 1) {
-        return vals;
-    }
-    else {
-        const result = [];
-        const chunkSize = vals.length / dims[0];
-        const chunkDims = dims.slice(1);
-        for (let i = 0; i < vals.length; i += chunkSize) {
-            const chunk = vals.slice(i, i + chunkSize);
-            result.push(foldVals(chunk, chunkDims));
-        }
-        return result;
-    }
-}
-function _fromApiVal(vals, valIndex, tpe) {
-    if (vals.length === 0) {
-        throw new Error('Not enough Vals');
-    }
-    const firstVal = vals[`${valIndex}`];
-    if (tpe === 'Bool' && firstVal.type === tpe) {
-        return [firstVal.value, valIndex + 1];
-    }
-    else if ((tpe === 'U256' || tpe === 'I256') && firstVal.type === tpe) {
-        return [decodeNumber256(firstVal.value), valIndex + 1];
-    }
-    else if ((tpe === 'ByteVec' || tpe === 'Address') && firstVal.type === tpe) {
-        return [firstVal.value, valIndex + 1];
-    }
-    else {
-        const [baseType, dims] = decodeArrayType(tpe);
-        const arraySize = dims.reduce((a, b) => a * b);
-        const nextIndex = valIndex + arraySize;
-        const valsToUse = vals.slice(valIndex, nextIndex);
-        if (valsToUse.length == arraySize && valsToUse.every((val) => val.type === baseType)) {
-            const localVals = valsToUse.map((val) => fromApiVal(val, baseType));
-            return [foldVals(localVals, dims), nextIndex];
-        }
-        else {
-            throw new Error(`Invalid array Val type: ${valsToUse}, ${tpe}`);
-        }
-    }
-}
 function fromApiFields(vals, fieldsSig) {
-    return fromApiVals(vals, fieldsSig.names, fieldsSig.types);
+    return (0, api_1.fromApiVals)(vals, fieldsSig.names, fieldsSig.types);
 }
 function fromApiEventFields(vals, eventSig) {
-    return fromApiVals(vals, eventSig.fieldNames, eventSig.fieldTypes);
-}
-function fromApiVals(vals, names, types) {
-    let valIndex = 0;
-    const result = {};
-    types.forEach((currentType, index) => {
-        const currentName = names[`${index}`];
-        const [val, nextIndex] = _fromApiVal(vals, valIndex, currentType);
-        valIndex = nextIndex;
-        result[`${currentName}`] = val;
-    });
-    return result;
-}
-function fromApiArray(vals, types) {
-    let valIndex = 0;
-    const result = [];
-    for (const currentType of types) {
-        const [val, nextIndex] = _fromApiVal(vals, valIndex, currentType);
-        result.push(val);
-        valIndex = nextIndex;
-    }
-    return result;
-}
-function fromApiVal(v, tpe) {
-    if (v.type === 'Bool' && v.type === tpe) {
-        return v.value;
-    }
-    else if ((v.type === 'U256' || v.type === 'I256') && v.type === tpe) {
-        return decodeNumber256(v.value);
-    }
-    else if ((v.type === 'ByteVec' || v.type === 'Address') && v.type === tpe) {
-        return v.value;
-    }
-    else {
-        throw new Error(`Invalid node.Val type: ${v}`);
-    }
-}
-function toApiToken(token) {
-    return { id: token.id, amount: extractNumber256(token.amount) };
-}
-function fromApiToken(token) {
-    return { id: token.id, amount: decodeNumber256(token.amount) };
+    return (0, api_1.fromApiVals)(vals, eventSig.fieldNames, eventSig.fieldTypes);
 }
 function toApiAsset(asset) {
     return {
-        attoAlphAmount: extractNumber256(asset.alphAmount),
-        tokens: typeof asset.tokens !== 'undefined' ? asset.tokens.map(toApiToken) : []
+        attoAlphAmount: (0, api_1.toApiNumber256)(asset.alphAmount),
+        tokens: typeof asset.tokens !== 'undefined' ? asset.tokens.map(api_1.toApiToken) : []
     };
 }
 function fromApiAsset(asset) {
     return {
-        alphAmount: decodeNumber256(asset.attoAlphAmount),
-        tokens: typeof asset.tokens !== 'undefined' ? asset.tokens.map(fromApiToken) : undefined
+        alphAmount: (0, api_1.fromApiNumber256)(asset.attoAlphAmount),
+        tokens: (0, api_1.fromApiTokens)(asset.tokens)
     };
 }
 function getVal(vals, name) {
@@ -865,7 +722,7 @@ function toApiVals(fields, names, types) {
     return names.map((name, index) => {
         const val = getVal(fields, name);
         const tpe = types[`${index}`];
-        return toApiVal(val, tpe);
+        return (0, api_1.toApiVal)(val, tpe);
     });
 }
 function toApiInputAsset(inputAsset) {
@@ -880,8 +737,8 @@ function fromApiOutput(output) {
         return {
             type: 'AssetOutput',
             address: asset.address,
-            alphAmount: decodeNumber256(asset.attoAlphAmount),
-            tokens: asset.tokens.map(fromApiToken),
+            alphAmount: (0, api_1.fromApiNumber256)(asset.attoAlphAmount),
+            tokens: (0, api_1.fromApiTokens)(asset.tokens),
             lockTime: asset.lockTime,
             message: asset.message
         };
@@ -891,16 +748,13 @@ function fromApiOutput(output) {
         return {
             type: 'ContractOutput',
             address: asset.address,
-            alphAmount: decodeNumber256(asset.attoAlphAmount),
-            tokens: asset.tokens.map(fromApiToken)
+            alphAmount: (0, api_1.fromApiNumber256)(asset.attoAlphAmount),
+            tokens: (0, api_1.fromApiTokens)(asset.tokens)
         };
     }
     else {
         throw new Error(`Unknown output type: ${output}`);
     }
 }
-function fromApiDeployContractUnsignedTx(result) {
-    return { ...result, contractId: (0, utils_1.binToHex)((0, utils_1.contractIdFromAddress)(result.contractAddress)) };
-}
 (0, utils_1.assertType)();
 (0, utils_1.assertType)();