@alephium/web3 0.2.0-test.0 → 0.2.0-test.1

package/dist/src/contract/contract.js

@@ -39,7 +39,7 @@ 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.toApiVal = exports.extractArray = exports.Script = exports.Contract = exports.Artifact = exports.Project = exports.DEFAULT_COMPILER_OPTIONS = void 0;
 const buffer_1 = require("buffer/");
 const cryptojs = __importStar(require("crypto-js"));
 const crypto = __importStar(require("crypto"));
@@ -47,202 +47,359 @@ const fs_1 = __importDefault(require("fs"));
 const fs_2 = require("fs");
 const ralph = __importStar(require("./ralph"));
 const utils_1 = require("../utils");
-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';
+const global_1 = require("../global");
+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_COMPILER_OPTIONS = {
+    errorOnWarnings: true,
+    ignoreUnusedConstantsWarnings: true
+};
+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;
     }
 }
-class Common {
-    constructor(sourceCodeSha256, functions) {
-        this.sourceCodeSha256 = sourceCodeSha256;
-        this.functions = functions;
+class SourceFile {
+    constructor(type, typeId, sourceCode, contractPath) {
+        this.type = type;
+        this.typeId = typeId;
+        this.sourceCode = sourceCode;
+        this.sourceCodeHash = cryptojs.SHA256(sourceCode).toString();
+        this.contractPath = contractPath;
     }
-    static _getArtifactFromCache(codeHash) {
-        return this._artifactCache.get(codeHash);
+    getArtifactPath(artifactsRootPath) {
+        return artifactsRootPath + this.contractPath.slice(this.contractPath.indexOf('/')) + '.json';
     }
-    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);
-        }
+}
+class Compiled {
+    constructor(sourceFile, artifact, warnings) {
+        this.sourceFile = sourceFile;
+        this.artifact = artifact;
+        this.warnings = warnings;
     }
-    static _artifactsFolder() {
-        return './artifacts/';
+}
+class ProjectArtifact {
+    constructor(infos) {
+        this.infos = infos;
     }
-    static getSourceFile(path, _dirs) {
-        const parts = path.split('/');
-        const dirs = Array.from(_dirs);
-        if (parts.length === 1) {
-            return new SourceFile(dirs, path);
+    async saveToFile(rootPath) {
+        const filepath = rootPath + '/' + ProjectArtifact.artifactFileName;
+        const content = JSON.stringify(Object.fromEntries(this.infos), null, 2);
+        return fs_2.promises.writeFile(filepath, content);
+    }
+    sourceHasChanged(files) {
+        if (files.length !== this.infos.size) {
+            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);
-                }
+        for (const file of files) {
+            const info = this.infos.get(file.contractPath);
+            if (typeof info === 'undefined' || info.sourceCodeHash !== file.sourceCodeHash) {
+                return true;
             }
-        });
-        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 '';
-        });
-        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 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 files = new Map(Object.entries(JSON.parse(content.toString())));
+        return new ProjectArtifact(files);
+    }
+}
+ProjectArtifact.artifactFileName = '.project.json';
+class Project {
+    constructor(provider, contractsRootPath, artifactsRootPath, sourceFiles, contracts, scripts) {
+        this.nodeProvider = provider;
+        this.contractsRootPath = contractsRootPath;
+        this.artifactsRootPath = artifactsRootPath;
+        this.sourceFiles = sourceFiles;
+        this.contracts = contracts;
+        this.scripts = scripts;
+    }
+    getContractPath(path) {
+        return path.startsWith(`./${this.contractsRootPath}`)
+            ? path.slice(2)
+            : path.startsWith(this.contractsRootPath)
+                ? path
+                : this.contractsRootPath + '/' + path;
+    }
+    static checkCompilerWarnings(warnings, compilerOptions) {
+        const remains = compilerOptions.ignoreUnusedConstantsWarnings
+            ? warnings.filter((s) => !s.includes('unused constants'))
+            : warnings;
+        if (remains.length !== 0) {
+            const prefixPerWarning = '  - ';
+            const warningString = prefixPerWarning + remains.join('\n' + prefixPerWarning);
+            const output = 'Compilation warnings:\n' + warningString + '\n';
+            if (compilerOptions.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(path, compilerOptions) {
+        const contractPath = Project.currentProject.getContractPath(path);
+        const contract = Project.currentProject.contracts.find((c) => c.sourceFile.contractPath === contractPath);
+        if (typeof contract === 'undefined') {
+            throw new Error(`Contract ${contractPath} does not exist`);
+        }
+        Project.checkCompilerWarnings(contract.warnings, { ...exports.DEFAULT_COMPILER_OPTIONS, ...compilerOptions });
+        return contract.artifact;
     }
-    static checkFileNameExtension(fileName) {
-        if (!fileName.endsWith('.ral')) {
-            throw new Error('Smart contract file name should end with ".ral"');
+    static script(path, compilerOptions) {
+        const contractPath = Project.currentProject.getContractPath(path);
+        const script = Project.currentProject.scripts.find((c) => c.sourceFile.contractPath === contractPath);
+        if (typeof script === 'undefined') {
+            throw new Error(`Script ${contractPath} does not exist`);
         }
+        Project.checkCompilerWarnings(script.warnings, { ...exports.DEFAULT_COMPILER_OPTIONS, ...compilerOptions });
+        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 artifactsRootPath = this.artifactsRootPath;
+        const saveToFile = async function (compiled) {
+            const artifactPath = compiled.sourceFile.getArtifactPath(artifactsRootPath);
+            const folder = artifactPath.slice(0, artifactPath.lastIndexOf('/'));
+            if (!fs_1.default.existsSync(folder)) {
+                fs_1.default.mkdirSync(folder, { recursive: true });
+            }
+            return fs_2.promises.writeFile(artifactPath, compiled.artifact.toString());
+        };
+        for (const contract of this.contracts) {
+            await saveToFile(contract);
         }
-        else {
-            return compile(provider, sourceFile, contractStr, contractHash);
+        for (const script of this.scripts) {
+            await saveToFile(script);
         }
     }
-    _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);
+        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;
+    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 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 compile(provider, files, contractsRootPath, artifactsRootPath) {
+        const sourceStr = files.map((f) => f.sourceCode).join('\n');
+        const result = await provider.contracts.postContractsCompileProject({
+            code: sourceStr
+        });
+        const contracts = [];
+        const scripts = [];
+        result.contracts.forEach((contractResult, index) => {
+            const sourceFile = files[`${index}`];
+            const contract = Contract.fromCompileResult(sourceFile.typeId, 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);
+            scripts.push(new Compiled(sourceFile, script, scriptResult.warnings));
+        });
+        const project = new Project(provider, contractsRootPath, artifactsRootPath, files, contracts, scripts);
+        await project.saveArtifactsToFile();
+        await project.saveProjectArtifactToFile();
+        return project;
+    }
+    static async loadArtifacts(provider, files, projectArtifact, contractsRootPath, artifactsRootPath) {
+        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 artifactPath = file.getArtifactPath(artifactsRootPath);
+                if (file.type === SourceType.Contract) {
+                    const artifact = await Contract.fromArtifactFile(artifactPath);
+                    contracts.push(new Compiled(file, artifact, warnings));
+                }
+                else if (file.type === SourceType.Script) {
+                    const artifact = await Script.fromArtifactFile(artifactPath);
+                    scripts.push(new Compiled(file, artifact, warnings));
+                }
             }
+            return new Project(provider, contractsRootPath, artifactsRootPath, files, contracts, scripts);
         }
-        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, contractsRootPath, artifactsRootPath);
+        }
+    }
+    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 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);
+    }
+    static async loadSourceFiles(contractsRootPath) {
+        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(contractsRootPath, 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 loadContractStr(sourceFile) {
-        return Common._loadContractStr(sourceFile, [], (code) => Contract.checkCodeType(sourceFile.contractPath, code));
-    }
-    static async fromSource(provider, path) {
-        if (!fs_1.default.existsSync(Common._artifactsFolder())) {
-            fs_1.default.mkdirSync(Common._artifactsFolder(), { recursive: true });
+    static async build(contractsRootPath = 'contracts', artifactsRootPath = 'artifacts') {
+        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 sourceFile = this.getSourceFile(path, []);
-        const contract = await Common._from(provider, sourceFile, (sourceFile) => Contract.loadContractStr(sourceFile), Contract.compile);
-        this._putArtifactToCache(contract);
-        return contract;
+        else {
+            Project.currentProject = await Project.loadArtifacts(provider, sourceFiles, projectArtifact, contractsRootPath, artifactsRootPath);
+        }
+    }
+}
+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
+];
+class Artifact {
+    constructor(typeId, functions) {
+        this.typeId = typeId;
+        this.functions = functions;
+    }
+    publicFunctions() {
+        return this.functions.filter((func) => func.isPublic).map((func) => func.name);
+    }
+    usingPreapprovedAssetsFunctions() {
+        return this.functions.filter((func) => func.usePreapprovedAssets).map((func) => func.name);
+    }
+    usingAssetsInContractFunctions() {
+        return this.functions.filter((func) => func.useAssetsInContract).map((func) => func.name);
     }
-    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(typeId, bytecode, codeHash, fieldsSig, eventsSig, functions) {
+        super(typeId, functions);
+        this.bytecode = bytecode;
+        this.codeHash = codeHash;
+        this.fieldsSig = fieldsSig;
+        this.eventsSig = eventsSig;
     }
     // TODO: safely parse json
     static fromJson(artifact) {
-        if (artifact.sourceCodeSha256 == null ||
-            artifact.bytecode == null ||
+        if (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.sourceCodeSha256, artifact.bytecode, artifact.codeHash, artifact.fieldsSig, artifact.eventsSig, artifact.functions);
-        this._putArtifactToCache(contract);
+        const contract = new Contract(artifact.typeId, artifact.bytecode, 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);
+    }
     // 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);
+        const content = await fs_2.promises.readFile(path);
         const artifact = JSON.parse(content.toString());
         return Contract.fromJson(artifact);
     }
-    async fetchState(provider, address, group) {
-        const state = await provider.contracts.getContractsAddressState(address, { group: group });
+    async fetchState(address, group) {
+        const state = await Project.currentProject.nodeProvider.contracts.getContractsAddressState(address, {
+            group: group
+        });
         return this.fromApiContractState(state);
     }
     toString() {
-        return JSON.stringify({
-            sourceCodeSha256: this.sourceCodeSha256,
+        const object = {
+            typeId: this.typeId,
             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();
@@ -261,11 +418,11 @@ class Contract extends Common {
         bytes[0] = 3;
         return utils_1.bs58.encode(bytes);
     }
-    async _test(provider, funcName, params, expectPublic, accessType) {
+    async _test(funcName, params, expectPublic, accessType) {
         const apiParams = this.toTestContract(funcName, params);
-        const apiResult = await provider.contracts.postContractsTestContract(apiParams);
+        const apiResult = await Project.currentProject.nodeProvider.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 (isPublic === expectPublic) {
             const result = await this.fromTestContractResult(methodIndex, apiResult);
             return result;
@@ -274,11 +431,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) {
+        return this._test(funcName, params, true, 'public');
     }
-    async testPrivateMethod(provider, funcName, params) {
-        return this._test(provider, funcName, params, false, 'private');
+    async testPrivateMethod(funcName, params) {
+        return this._test(funcName, params, false, 'private');
     }
     toApiFields(fields) {
         if (typeof fields === 'undefined') {
@@ -319,30 +476,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);
+        const contract = Project.currentProject.contractByCodeHash(state.codeHash);
         return {
             address: state.address,
             contractId: (0, utils_1.binToHex)((0, utils_1.contractIdFromAddress)(state.address)),
@@ -350,7 +485,7 @@ 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)
         };
     }
@@ -363,7 +498,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 {
@@ -424,71 +559,43 @@ 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(typeId, bytecodeTemplate, fieldsSig, functions) {
+        super(typeId, functions);
         this.bytecodeTemplate = bytecodeTemplate;
         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(typeId, result) {
+        return new Script(typeId, result.bytecodeTemplate, result.fields, result.functions);
     }
     // TODO: safely parse json
     static fromJson(artifact) {
-        if (artifact.sourceCodeSha256 == null ||
-            artifact.bytecodeTemplate == null ||
-            artifact.fieldsSig == null ||
-            artifact.functions == null) {
+        if (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.typeId, artifact.bytecodeTemplate, 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);
+        const content = await fs_2.promises.readFile(path);
         const artifact = JSON.parse(content.toString());
         return this.fromJson(artifact);
     }
     toString() {
-        return JSON.stringify({
-            sourceCodeSha256: this.sourceCodeSha256,
+        const object = {
+            typeId: this.typeId,
             bytecodeTemplate: this.bytecodeTemplate,
             fieldsSig: this.fieldsSig,
             functions: this.functions
-        }, null, 2);
+        };
+        return JSON.stringify(object, null, 2);
     }
     async paramsForDeployment(params) {
         const signerParams = {
@@ -752,7 +859,7 @@ 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) => {