@alephium/web3 0.2.0-test.0 → 0.2.0

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,178 +43,369 @@ 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.Common = 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";
+    SourceType[SourceType["Script"] = 1] = "Script";
+    SourceType[SourceType["AbstractContract"] = 2] = "AbstractContract";
+    SourceType[SourceType["Interface"] = 3] = "Interface";
+})(SourceType || (SourceType = {}));
+exports.DEFAULT_NODE_COMPILER_OPTIONS = {
+    ignoreUnusedConstantsWarnings: false,
+    ignoreUnusedVariablesWarnings: false,
+    ignoreUnusedFieldsWarnings: false,
+    ignoreUnusedPrivateFunctionsWarnings: false,
+    ignoreReadonlyCheckWarnings: 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;
+    }
+    match(str) {
+        const results = str.match(this.matcher);
+        return results === null ? 0 : results.length;
+    }
+}
 class SourceFile {
-    constructor(dirs, fileName) {
-        this.dirs = dirs;
-        this.dirPath = dirs.length === 0 ? '' : dirs.join('/') + '/';
-        if (fileName.endsWith('.json')) {
-            this.contractPath = './contracts/' + this.dirPath + fileName.slice(0, -5);
-            this.artifactPath = './artifacts/' + this.dirPath + fileName;
-        }
-        else {
-            this.contractPath = './contracts/' + this.dirPath + fileName;
-            this.artifactPath = './artifacts/' + this.dirPath + fileName + '.json';
-        }
+    constructor(type, sourceCode, sourceCodeHash, contractPath) {
+        this.type = type;
+        this.sourceCode = sourceCode;
+        this.sourceCodeHash = sourceCodeHash;
+        this.contractPath = contractPath;
+    }
+    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 Common {
-    constructor(sourceCodeSha256, functions) {
-        this.sourceCodeSha256 = sourceCodeSha256;
-        this.functions = functions;
+class Compiled {
+    constructor(sourceFile, artifact, warnings) {
+        this.sourceFile = sourceFile;
+        this.artifact = artifact;
+        this.warnings = warnings;
     }
-    static _getArtifactFromCache(codeHash) {
-        return this._artifactCache.get(codeHash);
+}
+class ProjectArtifact {
+    constructor(compilerOptionsUsed, infos) {
+        ProjectArtifact.checkCompilerOptionsParameter(compilerOptionsUsed);
+        this.compilerOptionsUsed = compilerOptionsUsed;
+        this.infos = infos;
     }
-    static _putArtifactToCache(contract) {
-        if (!this._artifactCache.has(contract.codeHash)) {
-            if (this._artifactCache.size >= this.artifactCacheCapacity) {
-                const keyToDelete = this._artifactCache.keys().next().value;
-                this._artifactCache.delete(keyToDelete);
-            }
-            this._artifactCache.set(contract.codeHash, contract);
+    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}`);
         }
     }
-    static _artifactsFolder() {
-        return './artifacts/';
+    async saveToFile(rootPath) {
+        const filepath = rootPath + '/' + ProjectArtifact.artifactFileName;
+        const artifact = { compilerOptionsUsed: this.compilerOptionsUsed, infos: Object.fromEntries(this.infos) };
+        const content = JSON.stringify(artifact, null, 2);
+        return fs_2.promises.writeFile(filepath, content);
     }
-    static getSourceFile(path, _dirs) {
-        const parts = path.split('/');
-        const dirs = Array.from(_dirs);
-        if (parts.length === 1) {
-            return new SourceFile(dirs, path);
+    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;
         }
-        parts.slice(0, parts.length - 1).forEach((part) => {
-            switch (part) {
-                case '.': {
-                    break;
-                }
-                case '..': {
-                    if (dirs.length === 0) {
-                        throw new Error('Invalid file path: ' + path);
-                    }
-                    dirs.pop();
-                    break;
-                }
-                default: {
-                    dirs.push(part);
-                }
+        if (files.length !== this.infos.size) {
+            return true;
+        }
+        for (const file of files) {
+            const info = this.infos.get(file.contractPath);
+            if (typeof info === 'undefined' || info.sourceCodeHash !== file.sourceCodeHash) {
+                return true;
             }
+        }
+        return false;
+    }
+    static async from(rootPath) {
+        const filepath = 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, 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
+            });
         });
-        return new SourceFile(dirs, parts[parts.length - 1]);
-    }
-    static async _handleImports(pathes, contractStr, importsCache) {
-        const localImportsCache = [];
-        let result = contractStr.replace(Common.importRegex, (match) => {
-            localImportsCache.push(match);
-            return '';
+        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: []
+            });
         });
-        for (const myImport of localImportsCache) {
-            const relativePath = myImport.slice(8, -1);
-            const importSourceFile = this.getSourceFile(relativePath, pathes);
-            if (!importsCache.includes(importSourceFile.contractPath)) {
-                importsCache.push(importSourceFile.contractPath);
-                const importContractStr = await Common._loadContractStr(importSourceFile, importsCache, (code) => Contract.checkCodeType(importSourceFile.contractPath, code));
-                result = result.concat('\n', importContractStr);
+        return new ProjectArtifact(compilerOptions, files);
+    }
+    getContractPath(path) {
+        return path.startsWith(`./${this.contractsRootDir}`)
+            ? path.slice(2)
+            : path.startsWith(this.contractsRootDir)
+                ? path
+                : this.contractsRootDir + '/' + path;
+    }
+    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);
             }
         }
-        return result;
     }
-    static async _loadContractStr(sourceFile, importsCache, validate) {
-        const contractPath = sourceFile.contractPath;
-        const contractBuffer = await fs_2.promises.readFile(contractPath);
-        const contractStr = contractBuffer.toString();
-        validate(contractStr);
-        return Common._handleImports(sourceFile.dirs, contractStr, importsCache);
+    static contract(name) {
+        const contract = Project.currentProject.contracts.find((c) => c.artifact.name === name);
+        if (typeof contract === 'undefined') {
+            throw new Error(`Contract "${name}" does not exist`);
+        }
+        return contract.artifact;
     }
-    static checkFileNameExtension(fileName) {
-        if (!fileName.endsWith('.ral')) {
-            throw new Error('Smart contract file name should end with ".ral"');
+    static script(name) {
+        const script = Project.currentProject.scripts.find((c) => c.artifact.name === name);
+        if (typeof script === 'undefined') {
+            throw new Error(`Script "${name}" does not exist`);
         }
+        return script.artifact;
     }
-    static async _from(provider, sourceFile, loadContractStr, compile) {
-        Common.checkFileNameExtension(sourceFile.contractPath);
-        const contractStr = await loadContractStr(sourceFile, []);
-        const contractHash = cryptojs.SHA256(contractStr).toString();
-        const existingContract = this._getArtifactFromCache(contractHash);
-        if (typeof existingContract !== 'undefined') {
-            return existingContract;
+    async saveArtifactsToFile() {
+        const artifactsRootDir = this.artifactsRootDir;
+        const saveToFile = async function (compiled) {
+            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(artifactDir, compiled.artifact.toString());
+        };
+        for (const contract of this.contracts) {
+            saveToFile(contract);
         }
-        else {
-            return compile(provider, sourceFile, contractStr, contractHash);
+        for (const script of this.scripts) {
+            await saveToFile(script);
         }
+        await this.projectArtifact.saveToFile(this.artifactsRootDir);
     }
-    _saveToFile(sourceFile) {
-        const folder = Common._artifactsFolder() + sourceFile.dirPath;
-        if (!fs_1.default.existsSync(folder)) {
-            fs_1.default.mkdirSync(folder, { recursive: true });
+    contractByCodeHash(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 fs_2.promises.writeFile(sourceFile.artifactPath, this.toString());
+        return contract.artifact;
     }
-}
-exports.Common = Common;
-Common.importRegex = new RegExp('^import "([^"/]+/(([^"]+)/)?)?[a-z][a-z_0-9]*.ral"', 'mg');
-Common.contractRegex = new RegExp('^TxContract [A-Z][a-zA-Z0-9]*', 'mg');
-Common.interfaceRegex = new RegExp('^Interface [A-Z][a-zA-Z0-9]* \\{', 'mg');
-Common.scriptRegex = new RegExp('^TxScript [A-Z][a-zA-Z0-9]*', 'mg');
-Common._artifactCache = new Map();
-Common.artifactCacheCapacity = 20;
-class Contract extends Common {
-    constructor(sourceCodeSha256, bytecode, codeHash, fieldsSig, eventsSig, functions) {
-        super(sourceCodeSha256, functions);
-        this.bytecode = bytecode;
-        this.codeHash = codeHash;
-        this.fieldsSig = fieldsSig;
-        this.eventsSig = eventsSig;
+    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,
+            compilerOptions: compilerOptions
+        });
+        const contracts = [];
+        const scripts = [];
+        result.contracts.forEach((contractResult, index) => {
+            const sourceFile = files[`${index}`];
+            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(scriptResult);
+            scripts.push(new Compiled(sourceFile, script, scriptResult.warnings));
+        });
+        const projectArtifact = Project.buildProjectArtifact(files, contracts, scripts, compilerOptions);
+        const project = new Project(contractsRootDir, artifactsRootDir, files, contracts, scripts, errorOnWarnings, projectArtifact);
+        await project.saveArtifactsToFile();
+        return project;
     }
-    static checkCodeType(fileName, contractStr) {
-        const interfaceMatches = contractStr.match(Contract.interfaceRegex);
-        const contractMatches = contractStr.match(Contract.contractRegex);
-        if (interfaceMatches === null && contractMatches === null) {
-            throw new Error(`No contract found in: ${fileName}`);
-        }
-        if (interfaceMatches && contractMatches) {
-            throw new Error(`Multiple contracts and interfaces in: ${fileName}`);
-        }
-        if (interfaceMatches === null) {
-            if (contractMatches !== null && contractMatches.length > 1) {
-                throw new Error(`Multiple contracts in: ${fileName}`);
+    static async loadArtifacts(provider, files, projectArtifact, contractsRootDir, artifactsRootDir, errorOnWarnings, compilerOptions) {
+        try {
+            const contracts = [];
+            const scripts = [];
+            for (const file of files) {
+                const info = projectArtifact.infos.get(file.contractPath);
+                if (typeof info === 'undefined') {
+                    throw Error(`Unable to find project info for ${file.contractPath}, please rebuild the project`);
+                }
+                const warnings = info.warnings;
+                const artifactDir = file.getArtifactPath(artifactsRootDir);
+                if (file.type === SourceType.Contract) {
+                    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(artifactDir, info.bytecodeDebugPatch);
+                    scripts.push(new Compiled(file, artifact, warnings));
+                }
             }
+            return new Project(contractsRootDir, artifactsRootDir, files, contracts, scripts, errorOnWarnings, projectArtifact);
         }
-        if (contractMatches === null) {
-            if (interfaceMatches !== null && interfaceMatches.length > 1) {
-                throw new Error(`Multiple interfaces in: ${fileName}`);
+        catch (error) {
+            console.log(`Failed to load artifacts, error: ${error}, try to re-compile contracts...`);
+            return Project.compile(provider, files, contractsRootDir, artifactsRootDir, errorOnWarnings, compilerOptions);
+        }
+    }
+    static async loadSourceFile(dirPath, filename) {
+        const contractPath = dirPath + '/' + filename;
+        if (!filename.endsWith('.ral')) {
+            throw new Error(`Invalid filename: ${contractPath}, smart contract file name should end with ".ral"`);
+        }
+        const sourceBuffer = await fs_2.promises.readFile(contractPath);
+        const sourceStr = sourceBuffer.toString();
+        const results = this.matchers.map((m) => m.match(sourceStr));
+        const matchNumber = results.reduce((a, b) => a + b, 0);
+        if (matchNumber === 0) {
+            throw new Error(`No contract defined in file: ${contractPath}`);
+        }
+        if (matchNumber > 1) {
+            throw new Error(`Multiple definitions in file: ${contractPath}`);
+        }
+        const matcherIndex = results.indexOf(1);
+        const type = this.matchers[`${matcherIndex}`].type;
+        return SourceFile.from(type, sourceStr, contractPath);
+    }
+    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) {
+                if (dirent.isFile()) {
+                    const file = await Project.loadSourceFile(dirPath, dirent.name);
+                    results.push(file);
+                }
+                else {
+                    const newPath = dirPath + '/' + dirent.name;
+                    await loadDir(newPath, results);
+                }
             }
+        };
+        const 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(compilerOptionsPartial = {}, contractsRootDir = Project.DEFAULT_CONTRACTS_DIR, artifactsRootDir = Project.DEFAULT_ARTIFACTS_DIR) {
+        const provider = (0, global_1.getCurrentNodeProvider)();
+        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 {
+            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.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;
     }
-    static async loadContractStr(sourceFile) {
-        return Common._loadContractStr(sourceFile, [], (code) => Contract.checkCodeType(sourceFile.contractPath, code));
+    publicFunctions() {
+        return this.functions.filter((func) => func.isPublic).map((func) => func.name);
     }
-    static async fromSource(provider, path) {
-        if (!fs_1.default.existsSync(Common._artifactsFolder())) {
-            fs_1.default.mkdirSync(Common._artifactsFolder(), { recursive: true });
-        }
-        const sourceFile = this.getSourceFile(path, []);
-        const contract = await Common._from(provider, sourceFile, (sourceFile) => Contract.loadContractStr(sourceFile), Contract.compile);
-        this._putArtifactToCache(contract);
-        return contract;
+    usingPreapprovedAssetsFunctions() {
+        return this.functions.filter((func) => func.usePreapprovedAssets).map((func) => func.name);
+    }
+    usingAssetsInContractFunctions() {
+        return this.functions.filter((func) => func.useAssetsInContract).map((func) => func.name);
     }
-    static async compile(provider, sourceFile, contractStr, contractHash) {
-        const compiled = await provider.contracts.postContractsCompileContract({ code: contractStr });
-        const artifact = new Contract(contractHash, compiled.bytecode, compiled.codeHash, compiled.fields, compiled.events, compiled.functions);
-        await artifact._saveToFile(sourceFile);
-        return artifact;
+}
+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) {
-        if (artifact.sourceCodeSha256 == null ||
+    static fromJson(artifact, bytecodeDebugPatch = '', codeHashDebug = '') {
+        if (artifact.version == null ||
+            artifact.name == null ||
             artifact.bytecode == null ||
             artifact.codeHash == null ||
             artifact.fieldsSig == null ||
@@ -218,31 +413,35 @@ class Contract extends Common {
             artifact.functions == null) {
             throw Error('The artifact JSON for contract is incomplete');
         }
-        const contract = new Contract(artifact.sourceCodeSha256, artifact.bytecode, artifact.codeHash, artifact.fieldsSig, artifact.eventsSig, artifact.functions);
-        this._putArtifactToCache(contract);
+        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) {
-        const sourceFile = this.getSourceFile(path, []);
-        const artifactPath = sourceFile.artifactPath;
-        const content = await fs_2.promises.readFile(artifactPath);
+    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(provider, address, group) {
-        const state = await provider.contracts.getContractsAddressState(address, { group: group });
+    async fetchState(address, group) {
+        const state = await __1.web3.getCurrentNodeProvider().contracts.getContractsAddressState(address, {
+            group: group
+        });
         return this.fromApiContractState(state);
     }
     toString() {
-        return JSON.stringify({
-            sourceCodeSha256: this.sourceCodeSha256,
+        const object = {
+            version: this.version,
+            name: this.name,
             bytecode: this.bytecode,
             codeHash: this.codeHash,
             fieldsSig: this.fieldsSig,
             eventsSig: this.eventsSig,
             functions: this.functions
-        }, null, 2);
+        };
+        return JSON.stringify(object, null, 2);
     }
     toState(fields, asset, address) {
         const addressDef = typeof address !== 'undefined' ? address : Contract.randomAddress();
@@ -256,16 +455,27 @@ class Contract extends Common {
             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(provider, 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 provider.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}`].signature.indexOf('pub ') !== -1;
+        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;
@@ -274,11 +484,11 @@ class Contract extends Common {
             throw new Error(`The test method ${funcName} is not ${accessType}`);
         }
     }
-    async testPublicMethod(provider, funcName, params) {
-        return this._test(provider, funcName, params, true, 'public');
+    async testPublicMethod(funcName, params, printDebugMessages = true) {
+        return this._test(funcName, params, true, 'public', printDebugMessages);
     }
-    async testPrivateMethod(provider, funcName, params) {
-        return this._test(provider, funcName, params, false, 'private');
+    async testPrivateMethod(funcName, params, printDebugMessages = true) {
+        return this._test(funcName, params, false, 'private', printDebugMessages);
     }
     toApiFields(fields) {
         if (typeof fields === 'undefined') {
@@ -310,7 +520,7 @@ class Contract extends Common {
         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),
@@ -319,30 +529,8 @@ class Contract extends Common {
             inputAssets: toApiInputAssets(params.inputAssets)
         };
     }
-    static async fromCodeHash(codeHash) {
-        const cached = this._getArtifactFromCache(codeHash);
-        if (typeof cached !== 'undefined') {
-            return cached;
-        }
-        const files = await fs_2.promises.readdir(Common._artifactsFolder());
-        for (const file of files) {
-            if (file.endsWith('.ral.json')) {
-                try {
-                    const contract = await Contract.fromArtifactFile(file);
-                    if (contract.codeHash === codeHash) {
-                        return contract;
-                    }
-                }
-                catch (_) { }
-            }
-        }
-        throw new Error(`Unknown code with code hash: ${codeHash}`);
-    }
-    static async getFieldsSig(state) {
-        return Contract.fromCodeHash(state.codeHash).then((contract) => contract.fieldsSig);
-    }
-    async fromApiContractState(state) {
-        const contract = await Contract.fromCodeHash(state.codeHash);
+    fromApiContractState(state) {
+        const contract = Project.currentProject.contractByCodeHash(state.codeHash);
         return {
             address: state.address,
             contractId: (0, utils_1.binToHex)((0, utils_1.contractIdFromAddress)(state.address)),
@@ -350,11 +538,11 @@ class Contract extends Common {
             initialStateHash: state.initialStateHash,
             codeHash: state.codeHash,
             fields: fromApiFields(state.fields, contract.fieldsSig),
-            fieldsSig: await Contract.getFieldsSig(state),
+            fieldsSig: contract.fieldsSig,
             asset: fromApiAsset(state.asset)
         };
     }
-    static async fromApiEvent(event, codeHash) {
+    static fromApiEvent(event, codeHash) {
         let eventSig;
         if (event.eventIndex == -1) {
             eventSig = this.ContractCreatedEvent;
@@ -363,7 +551,7 @@ class Contract extends Common {
             eventSig = this.ContractDestroyedEvent;
         }
         else {
-            const contract = await Contract.fromCodeHash(codeHash);
+            const contract = Project.currentProject.contractByCodeHash(codeHash);
             eventSig = contract.eventsSig[event.eventIndex];
         }
         return {
@@ -373,18 +561,18 @@ class Contract extends Common {
             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) => this.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) {
@@ -393,29 +581,26 @@ class Contract extends Common {
                 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);
@@ -424,310 +609,86 @@ class Contract extends Common {
 exports.Contract = Contract;
 Contract.ContractCreatedEvent = {
     name: 'ContractCreated',
-    signature: 'event ContractCreated(address:Address)',
     fieldNames: ['address'],
     fieldTypes: ['Address']
 };
 Contract.ContractDestroyedEvent = {
     name: 'ContractDestroyed',
-    signature: 'event ContractDestroyed(address:Address)',
     fieldNames: ['address'],
     fieldTypes: ['Address']
 };
-class Script extends Common {
-    constructor(sourceCodeSha256, bytecodeTemplate, fieldsSig, functions) {
-        super(sourceCodeSha256, functions);
+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 checkCodeType(fileName, contractStr) {
-        const scriptMatches = contractStr.match(this.scriptRegex);
-        if (scriptMatches === null) {
-            throw new Error(`No script found in: ${fileName}`);
-        }
-        else if (scriptMatches.length > 1) {
-            throw new Error(`Multiple scripts in: ${fileName}`);
-        }
-        else {
-            return;
-        }
-    }
-    static async loadContractStr(sourceFile) {
-        return Common._loadContractStr(sourceFile, [], (code) => Script.checkCodeType(sourceFile.contractPath, code));
-    }
-    static async fromSource(provider, path) {
-        const sourceFile = this.getSourceFile(path, []);
-        return Common._from(provider, sourceFile, (sourceFile) => Script.loadContractStr(sourceFile), Script.compile);
-    }
-    static async compile(provider, sourceFile, scriptStr, contractHash) {
-        const compiled = await provider.contracts.postContractsCompileScript({ code: scriptStr });
-        const artifact = new Script(contractHash, compiled.bytecodeTemplate, compiled.fields, compiled.functions);
-        await artifact._saveToFile(sourceFile);
-        return artifact;
+    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.sourceCodeSha256 == 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.sourceCodeSha256, artifact.bytecodeTemplate, artifact.fieldsSig, artifact.functions);
+        return new Script(artifact.version, artifact.name, artifact.bytecodeTemplate, bytecodeDebugPatch, artifact.fieldsSig, artifact.functions);
     }
-    static async fromArtifactFile(path) {
-        const sourceFile = this.getSourceFile(path, []);
-        const artifactPath = sourceFile.artifactPath;
-        const content = await fs_2.promises.readFile(artifactPath);
+    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() {
-        return JSON.stringify({
-            sourceCodeSha256: this.sourceCodeSha256,
+        const object = {
+            version: this.version,
+            name: this.name,
             bytecodeTemplate: this.bytecodeTemplate,
             fieldsSig: this.fieldsSig,
             functions: this.functions
-        }, null, 2);
+        };
+        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) {
@@ -752,13 +713,13 @@ function toApiFields(fields, fieldsSig) {
     return toApiVals(fields, fieldsSig.names, fieldsSig.types);
 }
 function toApiArgs(args, funcSig) {
-    return toApiVals(args, funcSig.argNames, funcSig.argTypes);
+    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 toApiVal(val, tpe);
+        return (0, api_1.toApiVal)(val, tpe);
     });
 }
 function toApiInputAsset(inputAsset) {
@@ -773,8 +734,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
         };
@@ -784,16 +745,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)();