@alephium/web3 0.40.0 → 0.42.0

package/dist/src/contract/contract.js

@@ -39,35 +39,21 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.tryGetCallResult = exports.getTokenIdFromUnsignedTx = exports.getContractIdFromUnsignedTx = exports.getContractEventsCurrentCount = exports.multicallMethods = exports.callMethod = exports.subscribeContractEvents = exports.subscribeContractEvent = exports.decodeEvent = exports.subscribeContractDestroyedEvent = exports.subscribeContractCreatedEvent = exports.fetchContractState = exports.ContractInstance = exports.getMapItem = exports.RalphMap = exports.testMethod = exports.addStdIdToFields = exports.subscribeEventsFromContract = exports.decodeContractDestroyedEvent = exports.decodeContractCreatedEvent = exports.DestroyContractEventAddresses = exports.CreateContractEventAddresses = exports.ExecutableScript = exports.ContractFactory = exports.randomTxId = exports.fromApiEventFields = exports.fromApiArray = exports.getDefaultValue = exports.fromApiFields = exports.Script = exports.Contract = exports.Artifact = exports.Project = exports.Struct = exports.ProjectArtifact = exports.DEFAULT_COMPILER_OPTIONS = exports.DEFAULT_NODE_COMPILER_OPTIONS = exports.StdIdFieldName = void 0;
+exports.getTokenIdFromUnsignedTx = exports.getContractIdFromUnsignedTx = exports.getContractEventsCurrentCount = exports.multicallMethods = exports.callMethod = exports.subscribeContractEvents = exports.subscribeContractEvent = exports.decodeEvent = exports.subscribeContractDestroyedEvent = exports.subscribeContractCreatedEvent = exports.fetchContractState = exports.ContractInstance = exports.getMapItem = exports.RalphMap = exports.testMethod = exports.addStdIdToFields = exports.subscribeEventsFromContract = exports.decodeContractDestroyedEvent = exports.decodeContractCreatedEvent = exports.DestroyContractEventAddresses = exports.CreateContractEventAddresses = exports.ExecutableScript = exports.ContractFactory = exports.randomTxId = exports.fromApiEventFields = exports.fromApiArray = exports.getDefaultValue = exports.fromApiFields = exports.Script = exports.Contract = exports.Artifact = exports.Struct = exports.DEFAULT_COMPILER_OPTIONS = exports.DEFAULT_NODE_COMPILER_OPTIONS = exports.StdIdFieldName = void 0;
 const buffer_1 = require("buffer/");
-const fs_1 = __importDefault(require("fs"));
-const fs_2 = require("fs");
+const fs_1 = require("fs");
 const api_1 = require("../api");
 const ralph = __importStar(require("./ralph"));
 const utils_1 = require("../utils");
 const global_1 = require("../global");
-const path = __importStar(require("path"));
 const events_1 = require("./events");
 const constants_1 = require("../constants");
 const blake = __importStar(require("blakejs"));
-const error_1 = require("../utils/error");
 const debug_1 = require("../debug");
 const codec_1 = require("../codec");
 const crypto = new utils_1.WebCrypto();
 exports.StdIdFieldName = '__stdInterfaceId';
-var SourceKind;
-(function (SourceKind) {
-    SourceKind[SourceKind["Contract"] = 0] = "Contract";
-    SourceKind[SourceKind["Script"] = 1] = "Script";
-    SourceKind[SourceKind["AbstractContract"] = 2] = "AbstractContract";
-    SourceKind[SourceKind["Interface"] = 3] = "Interface";
-    SourceKind[SourceKind["Struct"] = 4] = "Struct";
-})(SourceKind || (SourceKind = {}));
 exports.DEFAULT_NODE_COMPILER_OPTIONS = {
     ignoreUnusedConstantsWarnings: false,
     ignoreUnusedVariablesWarnings: false,
@@ -77,169 +63,6 @@ exports.DEFAULT_NODE_COMPILER_OPTIONS = {
     ignoreCheckExternalCallerWarnings: false
 };
 exports.DEFAULT_COMPILER_OPTIONS = { errorOnWarnings: true, ...exports.DEFAULT_NODE_COMPILER_OPTIONS };
-class TypedMatcher {
-    constructor(pattern, type) {
-        this.matcher = new RegExp(pattern, 'mg');
-        this.type = type;
-    }
-}
-function removeParentsPrefix(parts) {
-    let index = 0;
-    for (let i = 0; i < parts.length; i++) {
-        if (parts[`${i}`] === '..') {
-            index += 1;
-        }
-        else {
-            break;
-        }
-    }
-    return path.join(...parts.slice(index));
-}
-class SourceInfo {
-    getArtifactPath(artifactsRootDir) {
-        let fullPath;
-        if (this.isExternal) {
-            const relativePath = removeParentsPrefix(this.contractRelativePath.split(path.sep));
-            const externalPath = path.join('.external', relativePath);
-            fullPath = path.join(artifactsRootDir, externalPath);
-        }
-        else {
-            fullPath = path.join(artifactsRootDir, this.contractRelativePath);
-        }
-        return path.join(path.dirname(fullPath), `${this.name}.ral.json`);
-    }
-    constructor(type, name, sourceCode, sourceCodeHash, contractRelativePath, isExternal) {
-        this.type = type;
-        this.name = name;
-        this.sourceCode = sourceCode;
-        this.sourceCodeHash = sourceCodeHash;
-        this.contractRelativePath = contractRelativePath;
-        this.isExternal = isExternal;
-    }
-    static async from(type, name, sourceCode, contractRelativePath, isExternal) {
-        const sourceCodeHash = await crypto.subtle.digest('SHA-256', buffer_1.Buffer.from(sourceCode));
-        const sourceCodeHashHex = buffer_1.Buffer.from(sourceCodeHash).toString('hex');
-        return new SourceInfo(type, name, sourceCode, sourceCodeHashHex, contractRelativePath, isExternal);
-    }
-}
-class Compiled {
-    constructor(sourceInfo, artifact, warnings) {
-        this.sourceInfo = sourceInfo;
-        this.artifact = artifact;
-        this.warnings = warnings;
-    }
-}
-function findSourceInfoAtLineNumber(sources, line) {
-    let currentLine = 0;
-    const sourceInfosWithLine = sources.map((source) => {
-        const startIndex = currentLine + 1;
-        currentLine += source.sourceCode.split('\n').length;
-        const endIndex = currentLine;
-        return { sourceInfo: source, startIndex: startIndex, endIndex: endIndex };
-    });
-    const sourceInfo = sourceInfosWithLine.find((sourceInfoWithLine) => {
-        return line >= sourceInfoWithLine.startIndex && line <= sourceInfoWithLine.endIndex;
-    });
-    return sourceInfo;
-}
-class ProjectArtifact {
-    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}`);
-        }
-    }
-    constructor(fullNodeVersion, compilerOptionsUsed, infos) {
-        ProjectArtifact.checkCompilerOptionsParameter(compilerOptionsUsed);
-        this.fullNodeVersion = fullNodeVersion;
-        this.compilerOptionsUsed = compilerOptionsUsed;
-        this.infos = infos;
-    }
-    static isCodeChanged(current, previous) {
-        if (current.infos.size !== previous.infos.size) {
-            return true;
-        }
-        for (const [name, codeInfo] of current.infos) {
-            const prevCodeInfo = previous.infos.get(name);
-            if (prevCodeInfo?.codeHashDebug !== codeInfo.codeHashDebug) {
-                return true;
-            }
-        }
-        return false;
-    }
-    async saveToFile(rootPath) {
-        const filepath = path.join(rootPath, ProjectArtifact.artifactFileName);
-        const artifact = {
-            fullNodeVersion: this.fullNodeVersion,
-            compilerOptionsUsed: this.compilerOptionsUsed,
-            infos: Object.fromEntries(new Map([...this.infos].sort()))
-        };
-        const content = JSON.stringify(artifact, null, 2);
-        return fs_2.promises.writeFile(filepath, content);
-    }
-    needToReCompile(compilerOptions, sourceInfos, fullNodeVersion) {
-        ProjectArtifact.checkCompilerOptionsParameter(compilerOptions);
-        if (this.fullNodeVersion !== fullNodeVersion) {
-            return true;
-        }
-        const optionsMatched = Object.entries(compilerOptions).every(([key, inputOption]) => {
-            const usedOption = this.compilerOptionsUsed[`${key}`];
-            return usedOption === inputOption;
-        });
-        if (!optionsMatched) {
-            return true;
-        }
-        if (sourceInfos.length !== this.infos.size) {
-            return true;
-        }
-        for (const sourceInfo of sourceInfos) {
-            const info = this.infos.get(sourceInfo.name);
-            if (typeof info === 'undefined' || info.sourceCodeHash !== sourceInfo.sourceCodeHash) {
-                return true;
-            }
-        }
-        return false;
-    }
-    static async from(rootPath) {
-        const filepath = path.join(rootPath, ProjectArtifact.artifactFileName);
-        if (!fs_1.default.existsSync(filepath)) {
-            return undefined;
-        }
-        try {
-            const content = await fs_2.promises.readFile(filepath);
-            const json = JSON.parse(content.toString());
-            const fullNodeVersion = json.fullNodeVersion;
-            const compilerOptionsUsed = json.compilerOptionsUsed;
-            const files = new Map(Object.entries(json.infos));
-            return new ProjectArtifact(fullNodeVersion, compilerOptionsUsed, files);
-        }
-        catch (error) {
-            console.error(`Failed to load project artifact, error: ${error}`);
-            return undefined;
-        }
-    }
-}
-exports.ProjectArtifact = ProjectArtifact;
-ProjectArtifact.artifactFileName = '.project.json';
-function removeOldArtifacts(dir) {
-    const files = fs_1.default.readdirSync(dir);
-    files.forEach((file) => {
-        const filePath = path.join(dir, file);
-        const stat = fs_1.default.statSync(filePath);
-        if (stat.isDirectory()) {
-            removeOldArtifacts(filePath);
-        }
-        else if (filePath.endsWith('.ral.json') || filePath.endsWith('.ral')) {
-            fs_1.default.unlinkSync(filePath);
-        }
-    });
-    if (fs_1.default.readdirSync(dir).length === 0) {
-        fs_1.default.rmdirSync(dir);
-    }
-}
 class Struct {
     constructor(name, fieldNames, fieldTypes, isMutable) {
         this.name = name;
@@ -266,341 +89,12 @@ class Struct {
     }
 }
 exports.Struct = Struct;
-class Project {
-    static buildProjectArtifact(fullNodeVersion, sourceInfos, contracts, scripts, compilerOptions) {
-        const files = new Map();
-        contracts.forEach((c) => {
-            files.set(c.artifact.name, {
-                sourceFile: c.sourceInfo.contractRelativePath,
-                sourceCodeHash: c.sourceInfo.sourceCodeHash,
-                bytecodeDebugPatch: c.artifact.bytecodeDebugPatch,
-                codeHashDebug: c.artifact.codeHashDebug,
-                warnings: c.warnings
-            });
-        });
-        scripts.forEach((s) => {
-            files.set(s.artifact.name, {
-                sourceFile: s.sourceInfo.contractRelativePath,
-                sourceCodeHash: s.sourceInfo.sourceCodeHash,
-                bytecodeDebugPatch: s.artifact.bytecodeDebugPatch,
-                codeHashDebug: '',
-                warnings: s.warnings
-            });
-        });
-        const compiledSize = contracts.size + scripts.size;
-        sourceInfos.slice(compiledSize).forEach((c) => {
-            files.set(c.name, {
-                sourceFile: c.contractRelativePath,
-                sourceCodeHash: c.sourceCodeHash,
-                bytecodeDebugPatch: '',
-                codeHashDebug: '',
-                warnings: []
-            });
-        });
-        return new ProjectArtifact(fullNodeVersion, compilerOptions, files);
-    }
-    constructor(contractsRootDir, artifactsRootDir, sourceInfos, contracts, scripts, structs, errorOnWarnings, projectArtifact) {
-        this.contractsRootDir = contractsRootDir;
-        this.artifactsRootDir = artifactsRootDir;
-        this.sourceInfos = sourceInfos;
-        this.contracts = contracts;
-        this.scripts = scripts;
-        this.structs = structs;
-        this.projectArtifact = projectArtifact;
-        if (errorOnWarnings) {
-            Project.checkCompilerWarnings([
-                ...[...contracts.entries()].map((c) => c[1].warnings).flat(),
-                ...[...scripts.entries()].map((s) => s[1].warnings).flat()
-            ], errorOnWarnings);
-        }
-    }
-    static checkCompilerWarnings(warnings, errorOnWarnings) {
-        if (warnings.length !== 0) {
-            const prefixPerWarning = '  - ';
-            const warningString = prefixPerWarning + warnings.join('\n' + prefixPerWarning);
-            const output = `Compilation warnings:\n` + warningString + '\n';
-            if (errorOnWarnings) {
-                throw new Error(output);
-            }
-            else {
-                console.log(output);
-            }
-        }
-    }
-    static contract(name) {
-        const contract = Project.currentProject.contracts.get(name);
-        if (typeof contract === 'undefined') {
-            throw new Error(`Contract "${name}" does not exist`);
-        }
-        return contract.artifact;
-    }
-    static script(name) {
-        const script = Project.currentProject.scripts.get(name);
-        if (typeof script === 'undefined') {
-            throw new Error(`Script "${name}" does not exist`);
-        }
-        return script.artifact;
-    }
-    static async loadStructs(artifactsRootDir) {
-        const filePath = path.join(artifactsRootDir, 'structs.ral.json');
-        if (!fs_1.default.existsSync(filePath))
-            return [];
-        const content = await fs_2.promises.readFile(filePath);
-        const json = JSON.parse(content.toString());
-        if (!Array.isArray(json)) {
-            throw Error(`Invalid structs JSON: ${content}`);
-        }
-        return Array.from(json).map((item) => Struct.fromJson(item));
-    }
-    async saveStructsToFile() {
-        if (this.structs.length === 0)
-            return;
-        const structs = this.structs.map((s) => s.toJson());
-        const filePath = path.join(this.artifactsRootDir, 'structs.ral.json');
-        return fs_2.promises.writeFile(filePath, JSON.stringify(structs, null, 2));
-    }
-    async saveArtifactsToFile(projectRootDir) {
-        const artifactsRootDir = this.artifactsRootDir;
-        const saveToFile = async function (compiled) {
-            const artifactPath = compiled.sourceInfo.getArtifactPath(artifactsRootDir);
-            const dirname = path.dirname(artifactPath);
-            if (!fs_1.default.existsSync(dirname)) {
-                fs_1.default.mkdirSync(dirname, { recursive: true });
-            }
-            return fs_2.promises.writeFile(artifactPath, compiled.artifact.toString());
-        };
-        this.contracts.forEach((contract) => saveToFile(contract));
-        this.scripts.forEach((script) => saveToFile(script));
-        this.saveStructsToFile();
-        await this.projectArtifact.saveToFile(projectRootDir);
-    }
-    contractByCodeHash(codeHash) {
-        const contract = [...this.contracts.values()].find((c) => c.artifact.codeHash === codeHash || c.artifact.codeHashDebug == codeHash);
-        if (typeof contract === 'undefined') {
-            throw new Error(`Unknown code with code hash: ${codeHash}`);
-        }
-        return contract.artifact;
-    }
-    static async getCompileResult(provider, compilerOptions, sources) {
-        try {
-            const sourceStr = sources.map((f) => f.sourceCode).join('\n');
-            return await provider.contracts.postContractsCompileProject({
-                code: sourceStr,
-                compilerOptions: compilerOptions
-            });
-        }
-        catch (error) {
-            if (!(error instanceof Error)) {
-                throw error;
-            }
-            const parsed = (0, error_1.parseError)(error.message);
-            if (!parsed) {
-                throw error;
-            }
-            const sourceInfo = findSourceInfoAtLineNumber(sources, parsed.lineStart);
-            if (!sourceInfo) {
-                throw error;
-            }
-            const shiftIndex = parsed.lineStart - sourceInfo.startIndex + 1;
-            const newError = parsed.reformat(shiftIndex, sourceInfo.sourceInfo.contractRelativePath);
-            throw new Error(newError);
-        }
-    }
-    static async compile(fullNodeVersion, provider, sourceInfos, projectRootDir, contractsRootDir, artifactsRootDir, errorOnWarnings, compilerOptions) {
-        const removeDuplicates = sourceInfos.reduce((acc, sourceInfo) => {
-            if (acc.find((info) => info.sourceCodeHash === sourceInfo.sourceCodeHash) === undefined) {
-                acc.push(sourceInfo);
-            }
-            return acc;
-        }, []);
-        const result = await Project.getCompileResult(provider, compilerOptions, removeDuplicates);
-        const contracts = new Map();
-        const scripts = new Map();
-        const structs = result.structs === undefined ? [] : result.structs.map((item) => Struct.fromStructSig(item));
-        result.contracts.forEach((contractResult) => {
-            const sourceInfo = sourceInfos.find((sourceInfo) => sourceInfo.type === SourceKind.Contract && sourceInfo.name === contractResult.name);
-            if (sourceInfo === undefined) {
-                // this should never happen
-                throw new Error(`SourceInfo does not exist for contract ${contractResult.name}`);
-            }
-            const contract = Contract.fromCompileResult(contractResult, structs);
-            contracts.set(contract.name, new Compiled(sourceInfo, contract, contractResult.warnings));
-        });
-        result.scripts.forEach((scriptResult) => {
-            const sourceInfo = sourceInfos.find((sourceInfo) => sourceInfo.type === SourceKind.Script && sourceInfo.name === scriptResult.name);
-            if (sourceInfo === undefined) {
-                // this should never happen
-                throw new Error(`SourceInfo does not exist for script ${scriptResult.name}`);
-            }
-            const script = Script.fromCompileResult(scriptResult, structs);
-            scripts.set(script.name, new Compiled(sourceInfo, script, scriptResult.warnings));
-        });
-        const projectArtifact = Project.buildProjectArtifact(fullNodeVersion, sourceInfos, contracts, scripts, compilerOptions);
-        const project = new Project(contractsRootDir, artifactsRootDir, sourceInfos, contracts, scripts, structs, errorOnWarnings, projectArtifact);
-        await project.saveArtifactsToFile(projectRootDir);
-        return project;
-    }
-    static async loadArtifacts(provider, sourceInfos, projectArtifact, projectRootDir, contractsRootDir, artifactsRootDir, errorOnWarnings, compilerOptions) {
-        try {
-            const contracts = new Map();
-            const scripts = new Map();
-            const structs = await Project.loadStructs(artifactsRootDir);
-            for (const sourceInfo of sourceInfos) {
-                const info = projectArtifact.infos.get(sourceInfo.name);
-                if (typeof info === 'undefined') {
-                    throw Error(`Unable to find project info for ${sourceInfo.name}, please rebuild the project`);
-                }
-                const warnings = info.warnings;
-                const artifactDir = sourceInfo.getArtifactPath(artifactsRootDir);
-                if (sourceInfo.type === SourceKind.Contract) {
-                    const artifact = await Contract.fromArtifactFile(artifactDir, info.bytecodeDebugPatch, info.codeHashDebug, structs);
-                    contracts.set(artifact.name, new Compiled(sourceInfo, artifact, warnings));
-                }
-                else if (sourceInfo.type === SourceKind.Script) {
-                    const artifact = await Script.fromArtifactFile(artifactDir, info.bytecodeDebugPatch, structs);
-                    scripts.set(artifact.name, new Compiled(sourceInfo, artifact, warnings));
-                }
-            }
-            return new Project(contractsRootDir, artifactsRootDir, sourceInfos, contracts, scripts, structs, errorOnWarnings, projectArtifact);
-        }
-        catch (error) {
-            console.log(`Failed to load artifacts, error: ${error}, try to re-compile contracts...`);
-            return Project.compile(projectArtifact.fullNodeVersion, provider, sourceInfos, projectRootDir, contractsRootDir, artifactsRootDir, errorOnWarnings, compilerOptions);
-        }
-    }
-    static getImportSourcePath(projectRootDir, importPath) {
-        const parts = importPath.split('/');
-        if (parts.length > 1 && parts[0] === 'std') {
-            const currentDir = path.dirname(__filename);
-            return path.join(...[currentDir, '..', '..', '..', importPath]);
-        }
-        let moduleDir = projectRootDir;
-        while (true) {
-            const expectedPath = path.join(...[moduleDir, 'node_modules', importPath]);
-            if (fs_1.default.existsSync(expectedPath)) {
-                return expectedPath;
-            }
-            const oldModuleDir = moduleDir;
-            moduleDir = path.join(moduleDir, '..');
-            if (oldModuleDir === moduleDir) {
-                throw new Error(`Specified import file does not exist: ${importPath}`);
-            }
-        }
-    }
-    static async handleImports(projectRootDir, contractRootDir, sourceStr, importsCache) {
-        const localImportsCache = [];
-        const result = sourceStr.replace(Project.importRegex, (match) => {
-            localImportsCache.push(match);
-            return '';
-        });
-        const externalSourceInfos = [];
-        for (const myImport of localImportsCache) {
-            const originImportPath = myImport.slice(8, -1);
-            const importPath = originImportPath.endsWith('.ral') ? originImportPath : originImportPath + '.ral';
-            if (!importsCache.includes(importPath)) {
-                importsCache.push(importPath);
-                const sourcePath = Project.getImportSourcePath(projectRootDir, importPath);
-                const sourceInfos = await Project.loadSourceFile(projectRootDir, contractRootDir, sourcePath, importsCache, true);
-                externalSourceInfos.push(...sourceInfos);
-            }
-        }
-        return [result, externalSourceInfos];
-    }
-    static async loadSourceFile(projectRootDir, contractsRootDir, sourcePath, importsCache, isExternal) {
-        const contractRelativePath = path.relative(contractsRootDir, sourcePath);
-        if (!sourcePath.endsWith('.ral')) {
-            throw new Error(`Invalid filename: ${sourcePath}, smart contract file name should end with ".ral"`);
-        }
-        const sourceBuffer = await fs_2.promises.readFile(sourcePath);
-        const [sourceStr, externalSourceInfos] = await Project.handleImports(projectRootDir, contractsRootDir, sourceBuffer.toString(), importsCache);
-        if (sourceStr.match(new RegExp('^import "', 'mg')) !== null) {
-            throw new Error(`Invalid import statements, source: ${sourcePath}`);
-        }
-        const sourceInfos = externalSourceInfos;
-        for (const matcher of this.matchers) {
-            const results = sourceStr.matchAll(matcher.matcher);
-            for (const result of results) {
-                const sourceInfo = await SourceInfo.from(matcher.type, result[1], sourceStr, contractRelativePath, isExternal);
-                sourceInfos.push(sourceInfo);
-            }
-        }
-        return sourceInfos;
-    }
-    static async loadSourceFiles(projectRootDir, contractsRootDir) {
-        const importsCache = [];
-        const sourceInfos = [];
-        const loadDir = async function (dirPath) {
-            const dirents = await fs_2.promises.readdir(dirPath, { withFileTypes: true });
-            for (const dirent of dirents) {
-                if (dirent.isFile()) {
-                    const sourcePath = path.join(dirPath, dirent.name);
-                    const infos = await Project.loadSourceFile(projectRootDir, contractsRootDir, sourcePath, importsCache, false);
-                    sourceInfos.push(...infos);
-                }
-                else {
-                    const newPath = path.join(dirPath, dirent.name);
-                    await loadDir(newPath);
-                }
-            }
-        };
-        await loadDir(contractsRootDir);
-        const contractAndScriptSize = sourceInfos.filter((f) => f.type === SourceKind.Contract || f.type === SourceKind.Script).length;
-        if (sourceInfos.length === 0 || contractAndScriptSize === 0) {
-            throw new Error('Project have no source files');
-        }
-        return sourceInfos.sort((a, b) => a.type - b.type);
-    }
-    static async build(compilerOptionsPartial = {}, projectRootDir = '.', contractsRootDir = Project.DEFAULT_CONTRACTS_DIR, artifactsRootDir = Project.DEFAULT_ARTIFACTS_DIR, defaultFullNodeVersion = undefined) {
-        const provider = (0, global_1.getCurrentNodeProvider)();
-        const fullNodeVersion = defaultFullNodeVersion ?? (await provider.infos.getInfosVersion()).version;
-        const sourceFiles = await Project.loadSourceFiles(projectRootDir, contractsRootDir);
-        const { errorOnWarnings, ...nodeCompilerOptions } = { ...exports.DEFAULT_COMPILER_OPTIONS, ...compilerOptionsPartial };
-        const projectArtifact = await ProjectArtifact.from(projectRootDir);
-        if (projectArtifact === undefined ||
-            projectArtifact.needToReCompile(nodeCompilerOptions, sourceFiles, fullNodeVersion)) {
-            if (fs_1.default.existsSync(artifactsRootDir)) {
-                removeOldArtifacts(artifactsRootDir);
-            }
-            console.log(`Compiling contracts in folder "${contractsRootDir}"`);
-            Project.currentProject = await Project.compile(fullNodeVersion, provider, sourceFiles, projectRootDir, contractsRootDir, artifactsRootDir, errorOnWarnings, nodeCompilerOptions);
-        }
-        else {
-            console.log(`Contracts are compiled already. Loading them from folder "${artifactsRootDir}"`);
-            Project.currentProject = await Project.loadArtifacts(provider, sourceFiles, projectArtifact, projectRootDir, contractsRootDir, artifactsRootDir, errorOnWarnings, nodeCompilerOptions);
-        }
-    }
-}
-exports.Project = Project;
-Project.importRegex = new RegExp('^import "[^"./]+/[^"]*[a-z][a-z_0-9]*(.ral)?"', 'mg');
-Project.abstractContractMatcher = new TypedMatcher('^Abstract Contract ([A-Z][a-zA-Z0-9]*)', SourceKind.AbstractContract);
-Project.contractMatcher = new TypedMatcher('^Contract ([A-Z][a-zA-Z0-9]*)', SourceKind.Contract);
-Project.interfaceMatcher = new TypedMatcher('^Interface ([A-Z][a-zA-Z0-9]*)', SourceKind.Interface);
-Project.scriptMatcher = new TypedMatcher('^TxScript ([A-Z][a-zA-Z0-9]*)', SourceKind.Script);
-Project.structMatcher = new TypedMatcher('struct ([A-Z][a-zA-Z0-9]*)', SourceKind.Struct);
-Project.matchers = [
-    Project.abstractContractMatcher,
-    Project.contractMatcher,
-    Project.interfaceMatcher,
-    Project.scriptMatcher,
-    Project.structMatcher
-];
-Project.DEFAULT_CONTRACTS_DIR = 'contracts';
-Project.DEFAULT_ARTIFACTS_DIR = 'artifacts';
 class Artifact {
     constructor(version, name, functions) {
         this.version = version;
         this.name = name;
         this.functions = functions;
     }
-    publicFunctions() {
-        return this.functions.filter((func) => func.isPublic).map((func) => func.name);
-    }
-    usingPreapprovedAssetsFunctions() {
-        return this.functions.filter((func) => func.usePreapprovedAssets).map((func) => func.name);
-    }
-    usingAssetsInContractFunctions() {
-        return this.functions.filter((func) => func.useAssetsInContract).map((func) => func.name);
-    }
     async isDevnet(signer) {
         if (!signer.nodeProvider) {
             return false;
@@ -610,6 +104,15 @@ class Artifact {
     }
 }
 exports.Artifact = Artifact;
+function fromFunctionSig(sig) {
+    return {
+        name: sig.name,
+        paramNames: sig.paramNames,
+        paramTypes: sig.paramTypes,
+        paramIsMutable: sig.paramIsMutable,
+        returnTypes: sig.returnTypes
+    };
+}
 class Contract extends Artifact {
     constructor(version, name, bytecode, bytecodeDebugPatch, codeHash, codeHashDebug, fieldsSig, eventsSig, functions, constants, enums, structs, mapsSig, stdInterfaceId) {
         super(version, name, functions);
@@ -625,6 +128,16 @@ class Contract extends Artifact {
         this.stdInterfaceId = stdInterfaceId;
         this.bytecodeDebug = ralph.buildDebugBytecode(this.bytecode, this.bytecodeDebugPatch);
         this.codeHashDebug = codeHashDebug;
+        this.decodedMethods = codec_1.contract.contractCodec.decodeContract(buffer_1.Buffer.from(bytecode, 'hex')).methods;
+    }
+    publicFunctions() {
+        return this.functions.filter((_, index) => this.decodedMethods[`${index}`].isPublic);
+    }
+    usingPreapprovedAssetsFunctions() {
+        return this.functions.filter((_, index) => this.decodedMethods[`${index}`].usePreapprovedAssets);
+    }
+    usingAssetsInContractFunctions() {
+        return this.functions.filter((_, index) => this.decodedMethods[`${index}`].useContractAssets);
     }
     // TODO: safely parse json
     static fromJson(artifact, bytecodeDebugPatch = '', codeHashDebug = '', structs = []) {
@@ -643,11 +156,11 @@ class Contract extends Artifact {
         return contract;
     }
     static fromCompileResult(result, structs = []) {
-        return new Contract(result.version, result.name, result.bytecode, result.bytecodeDebugPatch, result.codeHash, result.codeHashDebug, result.fields, result.events, result.functions, result.constants, result.enums, structs, result.maps, result.stdInterfaceId);
+        return new Contract(result.version, result.name, result.bytecode, result.bytecodeDebugPatch, result.codeHash, result.codeHashDebug, result.fields, result.events, result.functions.map(fromFunctionSig), result.constants, result.enums, structs, result.maps, result.stdInterfaceId);
     }
     // support both 'code.ral' and 'code.ral.json'
     static async fromArtifactFile(path, bytecodeDebugPatch, codeHashDebug, structs = []) {
-        const content = await fs_2.promises.readFile(path);
+        const content = await fs_1.promises.readFile(path);
         const artifact = JSON.parse(content.toString());
         return Contract.fromJson(artifact, bytecodeDebugPatch, codeHashDebug, structs);
     }
@@ -768,9 +281,7 @@ class Contract extends Artifact {
         };
     }
     static fromApiContractState(state, getContractByCodeHash) {
-        const contract = getContractByCodeHash
-            ? getContractByCodeHash(state.codeHash)
-            : Project.currentProject.contractByCodeHash(state.codeHash);
+        const contract = getContractByCodeHash(state.codeHash);
         return contract.fromApiContractState(state);
     }
     static fromApiEvent(event, codeHash, txId, getContractByCodeHash) {
@@ -785,9 +296,7 @@ class Contract extends Artifact {
             name = Contract.ContractDestroyedEvent.name;
         }
         else {
-            const contract = getContractByCodeHash
-                ? getContractByCodeHash(codeHash)
-                : Project.currentProject.contractByCodeHash(codeHash);
+            const contract = getContractByCodeHash(codeHash);
             const eventSig = contract.eventsSig[event.eventIndex];
             fields = fromApiEventFields(event.fields, eventSig);
             name = eventSig.name;
@@ -801,7 +310,7 @@ class Contract extends Artifact {
             fields: fields
         };
     }
-    fromApiTestContractResult(methodName, result, txId) {
+    fromApiTestContractResult(methodName, result, txId, getContractByCodeHash) {
         const methodIndex = this.functions.findIndex((sig) => sig.name === methodName);
         const returnTypes = this.functions[`${methodIndex}`].returnTypes;
         const rawReturn = fromApiArray(result.returns, returnTypes, this.structs);
@@ -814,9 +323,9 @@ class Contract extends Artifact {
             contractAddress: result.address,
             returns: returns,
             gasUsed: result.gasUsed,
-            contracts: result.contracts.map((contract) => Contract.fromApiContractState(contract)),
+            contracts: result.contracts.map((contract) => Contract.fromApiContractState(contract, getContractByCodeHash)),
             txOutputs: result.txOutputs.map(fromApiOutput),
-            events: Contract.fromApiEvents(result.events, addressToCodeHash, txId),
+            events: Contract.fromApiEvents(result.events, addressToCodeHash, txId, getContractByCodeHash),
             debugMessages: result.debugMessages
         };
     }
@@ -871,7 +380,7 @@ class Contract extends Artifact {
     }
     fromApiCallContractResult(result, txId, methodIndex, getContractByCodeHash) {
         const returnTypes = this.functions[`${methodIndex}`].returnTypes;
-        const callResult = tryGetCallResult(result);
+        const callResult = (0, api_1.tryGetCallResult)(result);
         const rawReturn = fromApiArray(callResult.returns, returnTypes, this.structs);
         const returns = rawReturn.length === 0 ? null : rawReturn.length === 1 ? rawReturn[0] : rawReturn;
         const addressToCodeHash = new Map();
@@ -909,7 +418,7 @@ class Script extends Artifact {
         this.structs = structs;
     }
     static fromCompileResult(result, structs = []) {
-        return new Script(result.version, result.name, result.bytecodeTemplate, result.bytecodeDebugPatch, result.fields, result.functions, structs);
+        return new Script(result.version, result.name, result.bytecodeTemplate, result.bytecodeDebugPatch, result.fields, result.functions.map(fromFunctionSig), structs);
     }
     // TODO: safely parse json
     static fromJson(artifact, bytecodeDebugPatch = '', structs = []) {
@@ -923,7 +432,7 @@ class Script extends Artifact {
         return new Script(artifact.version, artifact.name, artifact.bytecodeTemplate, bytecodeDebugPatch, artifact.fieldsSig, artifact.functions, structs);
     }
     static async fromArtifactFile(path, bytecodeDebugPatch, structs = []) {
-        const content = await fs_2.promises.readFile(path);
+        const content = await fs_1.promises.readFile(path);
         const artifact = JSON.parse(content.toString());
         return this.fromJson(artifact, bytecodeDebugPatch, structs);
     }
@@ -1215,7 +724,9 @@ function genCodeForType(type, structs) {
     const { immFields, mutFields } = ralph.calcFieldSize(type, true, structs);
     const loadImmFieldByIndex = {
         isPublic: true,
-        assetModifier: 0,
+        usePreapprovedAssets: false,
+        useContractAssets: false,
+        usePayToContractOnly: false,
         argsLength: 1,
         localsLength: 1,
         returnLength: 1,
@@ -1243,7 +754,9 @@ function genCodeForType(type, structs) {
     };
     const destroy = {
         isPublic: true,
-        assetModifier: 2,
+        usePreapprovedAssets: false,
+        useContractAssets: true,
+        usePayToContractOnly: false,
         argsLength: 1,
         localsLength: 1,
         returnLength: 0,
@@ -1295,7 +808,7 @@ function mapsToExistingContracts(contract, parentContractId, group, initialMaps)
     });
     return contractStates;
 }
-async function testMethod(factory, methodName, params) {
+async function testMethod(factory, methodName, params, getContractByCodeHash) {
     const txId = params?.txId ?? randomTxId();
     const contract = factory.contract;
     const address = params.address ?? (0, utils_1.addressFromContractId)((0, utils_1.binToHex)(crypto.getRandomValues(new Uint8Array(32))));
@@ -1313,7 +826,7 @@ async function testMethod(factory, methodName, params) {
     });
     const apiResult = await (0, global_1.getCurrentNodeProvider)().contracts.postContractsTestContract(apiParams);
     const maps = existingContractsToMaps(contract, address, group, apiResult, initialMaps);
-    const testResult = contract.fromApiTestContractResult(methodName, apiResult, txId);
+    const testResult = contract.fromApiTestContractResult(methodName, apiResult, txId, getContractByCodeHash);
     contract.printDebugMessages(methodName, testResult.debugMessages);
     return {
         ...testResult,
@@ -1322,27 +835,35 @@ async function testMethod(factory, methodName, params) {
 }
 exports.testMethod = testMethod;
 class RalphMap {
-    constructor(parentContract, parentInstance, mapName) {
+    constructor(parentContract, parentContractId, mapName) {
         this.parentContract = parentContract;
-        this.parentInstance = parentInstance;
+        this.parentContractId = parentContractId;
         this.mapName = mapName;
+        this.groupIndex = (0, utils_1.groupOfAddress)((0, utils_1.addressFromContractId)(parentContractId));
     }
     async get(key) {
-        return getMapItem(this.parentContract, this.parentInstance, this.mapName, key);
+        return getMapItem(this.parentContract, this.parentContractId, this.groupIndex, this.mapName, key);
     }
     async contains(key) {
         return this.get(key).then((v) => v !== undefined);
     }
+    toJSON() {
+        return {
+            parentContractId: this.parentContractId,
+            mapName: this.mapName,
+            groupIndex: this.groupIndex
+        };
+    }
 }
 exports.RalphMap = RalphMap;
-async function getMapItem(parentContract, parentInstance, mapName, key) {
+async function getMapItem(parentContract, parentContractId, groupIndex, mapName, key) {
     const index = parentContract.mapsSig?.names.findIndex((name) => name === mapName);
     const mapType = index === undefined ? undefined : parentContract.mapsSig?.types[`${index}`];
     if (mapType === undefined) {
         throw new Error(`Map ${mapName} does not exist in contract ${parentContract.name}`);
     }
     const [keyType, valueType] = ralph.parseMapType(mapType);
-    const mapItemContractId = calcWrapperContractId(parentInstance.contractId, index, key, keyType, parentInstance.groupIndex);
+    const mapItemContractId = calcWrapperContractId(parentContractId, index, key, keyType, groupIndex);
     const mapItemAddress = (0, utils_1.addressFromContractId)(mapItemContractId);
     try {
         const state = await (0, global_1.getCurrentNodeProvider)().contracts.getContractsAddressState(mapItemAddress);
@@ -1562,10 +1083,3 @@ const getContractIdFromUnsignedTx = async (nodeProvider, unsignedTx) => {
 exports.getContractIdFromUnsignedTx = getContractIdFromUnsignedTx;
 // This function only works in the simple case where a single non-subcontract is created in the tx
 exports.getTokenIdFromUnsignedTx = exports.getContractIdFromUnsignedTx;
-function tryGetCallResult(result) {
-    if (result.type === 'CallContractFailed') {
-        throw new Error(`Failed to call contract, error: ${result.error}`);
-    }
-    return result;
-}
-exports.tryGetCallResult = tryGetCallResult;