@opcat-labs/scrypt-ts-transpiler-opcat 1.0.0

package/dist/compile/compilerWrapper.js

@@ -0,0 +1,1019 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileContractAsync = exports.compileContract = exports.getStaticDeclaration = exports.getAliasDeclaration = exports.getContractDeclaration = exports.getLibraryDeclaration = exports.getStructDeclaration = exports.getABIDeclaration = exports.getContractName = exports.getFullFilePath = exports.compilerVersion = exports.handleCompilerOutput = exports.compile = exports.settings2cmd = exports.compileAsync = exports.doCompileAsync = exports.DebugModeTag = exports.CompileResult = exports.BuildType = exports.CompileErrorType = exports.SOURCE_REG = void 0;
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const rimraf_1 = require("rimraf");
+const json_bigint_1 = __importDefault(require("json-bigint"));
+const resolver_1 = require("../resolver");
+const utils_1 = require("../utils");
+const findCompiler_1 = require("./findCompiler");
+const bitcoinjs_lib_1 = require("@scrypt-inc/bitcoinjs-lib");
+const tools = __importStar(require("uint8array-tools"));
+const scrypt_ts_opcat_1 = require("@opcat-labs/scrypt-ts-opcat");
+const indexer_1 = require("../indexer");
+const relinker_1 = require("../relinker");
+const SYNTAX_ERR_REG = /(?<filePath>[^\s]+):(?<line>\d+):(?<column>\d+):\n([^\n]+\n){3}(unexpected (?<unexpected>[^\n]+)\nexpecting (?<expecting>[^\n]+)|(?<message>[^\n]+))/g;
+const SEMANTIC_ERR_REG = /Error:(\s|\n)*(?<filePath>[^\s]+):(?<line>\d+):(?<column>\d+):(?<line1>\d+):(?<column1>\d+):*\n(?<message>[^\n]+)\n/g;
+const INTERNAL_ERR_REG = /Internal error:(?<message>.+)/;
+const WARNING_REG = /Warning:(\s|\n)*(?<filePath>[^\s]+):(?<line>\d+):(?<column>\d+):(?<line1>\d+):(?<column1>\d+):*\n(?<message>[^\n]+)\n/g;
+const JSONbigAlways = (0, json_bigint_1.default)({ alwaysParseAsBig: true, constructorAction: 'preserve' });
+//SOURCE_REG parser src eg: [0:6:3:8:4#Bar.constructor:0]
+exports.SOURCE_REG = /^(?<fileIndex>-?\d+):(?<line>\d+):(?<col>\d+):(?<endLine>\d+):(?<endCol>\d+)(#(?<tagStr>.+))?/;
+const RELATED_INFORMATION_REG = /(?<filePath>[^\s]+):(?<line>\d+):(?<column>\d+):(?<line1>\d+):(?<column1>\d+)/gi;
+// see VERSIONLOG.md
+var CompileErrorType;
+(function (CompileErrorType) {
+    CompileErrorType["SyntaxError"] = "SyntaxError";
+    CompileErrorType["SemanticError"] = "SemanticError";
+    CompileErrorType["InternalError"] = "InternalError";
+    CompileErrorType["Warning"] = "Warning";
+})(CompileErrorType || (exports.CompileErrorType = CompileErrorType = {}));
+var BuildType;
+(function (BuildType) {
+    BuildType["Debug"] = "debug";
+    BuildType["Release"] = "release";
+})(BuildType || (exports.BuildType = BuildType = {}));
+class CompileResult {
+    constructor(errors, warnings) {
+        this.errors = errors;
+        this.warnings = warnings;
+    }
+    toArtifact() {
+        const errors = this.errors.filter((e) => e.type !== CompileErrorType.Warning);
+        if (errors.length > 0) {
+            throw new Error(`CompileResult contains errors: ${errors.map((e) => e.message).join('\n')}`);
+        }
+        const artifact = {
+            version: scrypt_ts_opcat_1.CURRENT_CONTRACT_ARTIFACT_VERSION,
+            compilerVersion: this.compilerVersion || '0.0.0',
+            contract: this.contract || '',
+            md5: this.md5 || '',
+            structs: this.structs || [],
+            library: this.library || [],
+            alias: this.alias || [],
+            abi: this.abi || [],
+            stateProps: this.stateProps || [],
+            stateType: this.stateType,
+            buildType: this.buildType || BuildType.Release,
+            file: this.file || '',
+            hex: this.hex || '',
+        };
+        return artifact;
+    }
+}
+exports.CompileResult = CompileResult;
+var DebugModeTag;
+(function (DebugModeTag) {
+    DebugModeTag["FuncStart"] = "F0";
+    DebugModeTag["FuncEnd"] = "F1";
+    DebugModeTag["LoopStart"] = "L0";
+})(DebugModeTag || (exports.DebugModeTag = DebugModeTag = {}));
+function toOutputDir(artifactsDir, sourcePath) {
+    return (0, path_1.join)(artifactsDir, (0, path_1.basename)(sourcePath) + '-' + (0, utils_1.sha1)(sourcePath).substring(0, 10));
+}
+function doCompileAsync(source, settings, callback) {
+    const sourcePath = source.path;
+    const srcDir = (0, path_1.dirname)(sourcePath);
+    const curWorkingDir = settings.cwd || srcDir;
+    const timeout = settings.timeout || 1200000;
+    const sourceContent = source.content !== undefined ? source.content : (0, fs_1.readFileSync)(sourcePath, 'utf8');
+    const cmd = settings2cmd(sourcePath, settings);
+    const childProcess = (0, child_process_1.exec)(cmd, { cwd: curWorkingDir, timeout, killSignal: 'SIGKILL' }, (error, stdout) => {
+        if (error) {
+            console.error(`exec error: ${error} stdout: ${stdout}`);
+            if (callback) {
+                callback(error, null);
+            }
+            return;
+        }
+        if (callback) {
+            callback(null, {
+                path: sourcePath,
+                output: stdout,
+            });
+        }
+    });
+    const stdin = childProcess.stdin;
+    if (stdin) {
+        stdin.write(sourceContent, (error) => {
+            if (error) {
+                if (callback) {
+                    callback(error, null);
+                }
+                return;
+            }
+            stdin.end();
+        });
+    }
+    return childProcess;
+}
+exports.doCompileAsync = doCompileAsync;
+function compileAsync(source, settings) {
+    settings = Object.assign({}, defaultCompilingSettings, settings);
+    return new Promise((resolve, reject) => {
+        doCompileAsync(source, settings, (error, data) => {
+            if (error) {
+                reject(error);
+                return;
+            }
+            if (data) {
+                try {
+                    const result = handleCompilerOutput(source.path, settings, data.output);
+                    resolve(result);
+                }
+                catch (error) {
+                    reject(error);
+                }
+            }
+        });
+    });
+}
+exports.compileAsync = compileAsync;
+const defaultCompilingSettings = {
+    ast: true,
+    asm: false,
+    hex: true,
+    debug: false,
+    artifact: false,
+    outputDir: '',
+    outputToFiles: false,
+    cwd: '',
+    cmdPrefix: '',
+    cmdArgs: '',
+    buildType: BuildType.Release,
+    stdout: false,
+    sourceMap: false,
+    timeout: 1200000, // in ms
+    optimize: false,
+};
+function settings2cmd(sourcePath, settings) {
+    const srcDir = (0, path_1.dirname)(sourcePath);
+    //dir that store artifact file
+    const artifactDir = settings.outputDir || srcDir;
+    //dir that store ast,asm file
+    const outputDir = toOutputDir(artifactDir, sourcePath);
+    const cmdPrefix = settings.cmdPrefix || (0, findCompiler_1.findCompiler)();
+    let outOption = `-o "${outputDir}"`;
+    if (settings.stdout) {
+        outOption = '--stdout';
+        return `"${cmdPrefix}" compile ${settings.asm || settings.artifact ? '--asm' : ''} ${settings.hex ? '--hex' : ''} ${settings.optimize ? '-O' : ''} ${settings.ast || settings.artifact ? '--ast' : ''} ${settings.debug == true ? '--debug' : ''} -r ${outOption} ${settings.cmdArgs ? settings.cmdArgs : ''}`;
+    }
+    else {
+        if (!(0, fs_1.existsSync)(outputDir)) {
+            (0, fs_1.mkdirSync)(outputDir);
+        }
+    }
+    return `"${cmdPrefix}" compile ${settings.hex ? '--hex' : ''} ${settings.optimize ? '-O' : ''} ${settings.ast || settings.artifact ? '--ast' : ''} ${settings.debug == true ? '--debug' : ''} ${settings.sourceMap == true ? '--source-map' : ''} -r ${outOption} ${settings.cmdArgs ? settings.cmdArgs : ''}`;
+}
+exports.settings2cmd = settings2cmd;
+function compile(source, settings) {
+    const sourcePath = source.path;
+    const srcDir = (0, path_1.dirname)(sourcePath);
+    //dir that stores artifact file
+    const curWorkingDir = settings.cwd || srcDir;
+    settings = Object.assign({}, defaultCompilingSettings, settings);
+    const sourceContent = source.content !== undefined ? source.content : (0, fs_1.readFileSync)(sourcePath, 'utf8');
+    const maxBuffer = settings.stdout ? 1024 * 1024 * 100 : 1024 * 1024;
+    settings = Object.assign({}, defaultCompilingSettings, settings);
+    const cmd = settings2cmd(sourcePath, settings);
+    const output = (0, child_process_1.execSync)(cmd, {
+        input: sourceContent,
+        cwd: curWorkingDir,
+        timeout: settings.timeout,
+        maxBuffer: maxBuffer,
+    }).toString();
+    return handleCompilerOutput(sourcePath, settings, output);
+}
+exports.compile = compile;
+function calcHexMd5(hex) {
+    const chex = hex.replace(/<([^>]+)>/g, '<>');
+    return (0, utils_1.md5)(chex);
+}
+function getHex(hex) {
+    return hex.replace(/<([^>]+)>/g, '');
+}
+function findDisableOpCode(hex) {
+    const script = bitcoinjs_lib_1.script.decompile(tools.fromHex(hex));
+    return script.find((chuck) => {
+        if (typeof chuck === 'number') {
+            return (0, bitcoinjs_lib_1.isOpSuccess)(chuck);
+        }
+        return false;
+    });
+}
+function handleCompilerOutput(sourcePath, settings, output) {
+    const srcDir = (0, path_1.dirname)(sourcePath);
+    const sourceFileName = (0, path_1.basename)(sourcePath);
+    const artifactsDir = settings.outputDir || srcDir;
+    const outputDir = toOutputDir(artifactsDir, sourcePath);
+    const outputFiles = {};
+    try {
+        // Because the output of the compiler on the win32 platform uses crlf as a newline， here we change \r\n to \n. make SYNTAX_ERR_REG、SEMANTIC_ERR_REG、IMPORT_ERR_REG work.
+        output = output.split(/\r?\n/g).join('\n');
+        const result = new CompileResult([], []);
+        const cwd = settings.cmdPrefix ? settings.cmdPrefix : (0, findCompiler_1.findCompiler)();
+        if (!cwd) {
+            throw new Error('No sCrypt compiler found');
+        }
+        result.compilerVersion = compilerVersion(cwd);
+        result.buildType = settings.buildType || BuildType.Release;
+        if (output.startsWith('Error:') || output.startsWith('Warning:')) {
+            Object.assign(result, getErrorsAndWarnings(output, srcDir, sourceFileName));
+            if (result.errors.length > 0) {
+                return result;
+            }
+            if (settings.stdout && result.warnings.length > 0) {
+                // stdout not allowed warnings
+                return result;
+            }
+        }
+        if (settings.stdout) {
+            const stdout = JSONbigAlways.parse(output);
+            parserAst(result, stdout.ast, srcDir, sourceFileName, sourcePath);
+            parserASM(result, stdout.asm, settings, srcDir, sourceFileName);
+        }
+        else {
+            if (settings.ast || settings.artifact) {
+                const outputFilePath = getOutputFilePath(outputDir, 'ast');
+                const astFile = outputFilePath.replace('stdin', (0, path_1.basename)(sourcePath, '.scrypt'));
+                (0, fs_1.renameSync)(outputFilePath, astFile);
+                outputFiles['ast'] = astFile;
+                const ast = JSONbigAlways.parse((0, fs_1.readFileSync)(astFile, 'utf8'));
+                parserAst(result, ast, srcDir, sourceFileName, sourcePath);
+            }
+            if (settings.hex || settings.artifact) {
+                const outputFilePath = getOutputFilePath(outputDir, 'hex');
+                const hexFile = outputFilePath.replace('stdin', (0, path_1.basename)(sourcePath, '.scrypt'));
+                (0, fs_1.renameSync)(outputFilePath, hexFile);
+                outputFiles['hex'] = hexFile;
+                result.hex = (0, fs_1.readFileSync)(hexFile, 'utf8');
+                result.md5 = calcHexMd5(result.hex);
+            }
+            if (settings.sourceMap) {
+                const outputFilePath = getOutputFilePath(outputDir, 'map');
+                if (settings.artifact) {
+                    const dist = getOutputFilePath(artifactsDir, 'map');
+                    const sourceMapFile = dist.replace('stdin', (0, path_1.basename)(sourcePath, '.scrypt'));
+                    (0, fs_1.renameSync)(outputFilePath, sourceMapFile);
+                    result.sourceMapFile = (0, utils_1.path2uri)(sourceMapFile);
+                }
+                else {
+                    const sourceMapFile = outputFilePath.replace('stdin', (0, path_1.basename)(sourcePath, '.scrypt'));
+                    (0, fs_1.renameSync)(outputFilePath, sourceMapFile);
+                    outputFiles['map'] = sourceMapFile;
+                    result.sourceMapFile = (0, utils_1.path2uri)(sourceMapFile);
+                }
+            }
+            if (settings.debug) {
+                const outputFilePath = getOutputFilePath(outputDir, 'dbg');
+                const dbgFile = outputFilePath.replace('stdin', (0, path_1.basename)(sourcePath, '.scrypt'));
+                (0, fs_1.renameSync)(outputFilePath, dbgFile);
+                result.dbgFile = (0, utils_1.path2uri)(dbgFile);
+            }
+            // inject state type from transpiling result file `scrypt.index.json`
+            const indexFile = indexer_1.Indexer.queryIndexFile(sourcePath, process.cwd());
+            const pkgInfo = relinker_1.Relinker.getFilePackageInfo(sourcePath);
+            if (indexFile) {
+                const indexer = new indexer_1.Indexer(indexFile);
+                // set state type for libraries
+                result.library?.forEach((lib) => {
+                    const stateType = indexer.symbolInfos.get(lib.name ? relinker_1.Relinker.getUnRenamedSymbol(lib.name) : undefined)?.stateType;
+                    lib.stateType =
+                        stateType &&
+                            relinker_1.Relinker.getRenamedSymbol(stateType, pkgInfo.packageName, pkgInfo.packageVersion);
+                });
+                // set state type for contract
+                const stateType = indexer.symbolInfos.get(relinker_1.Relinker.getUnRenamedSymbol(result.contract))?.stateType;
+                result.stateType =
+                    stateType &&
+                        relinker_1.Relinker.getRenamedSymbol(stateType, pkgInfo.packageName, pkgInfo.packageVersion);
+            }
+            else {
+                throw new Error(`Cannot find \`scrypt.index.json\` file, run \`npm run build\` to generate it.`);
+            }
+            if (settings.artifact) {
+                const outputFilePath = getOutputFilePath(artifactsDir, 'artifact');
+                const artifactFile = outputFilePath.replace('stdin', (0, path_1.basename)(sourcePath, '.scrypt'));
+                const artifact = result.toArtifact();
+                (0, fs_1.writeFileSync)(artifactFile, JSON.stringify(artifact, (key, value) => {
+                    if (key === 'file') {
+                        return (0, path_1.relative)(artifactFile, value);
+                    }
+                    //ignore deprecated fields
+                    if (key == 'sources' || key == 'sourceMap' || key === 'asm')
+                        return undefined;
+                    else
+                        return value;
+                }, 2));
+            }
+            const indexer = new indexer_1.Indexer();
+            indexer.updateMd5(relinker_1.Relinker.getUnRenamedSymbol(result.contract), result.md5);
+            indexer.save();
+        }
+        return result;
+    }
+    finally {
+        doClean(settings, outputFiles, outputDir);
+    }
+}
+exports.handleCompilerOutput = handleCompilerOutput;
+function compilerVersion(cwd) {
+    try {
+        const text = (0, child_process_1.execSync)(`"${cwd}" version`).toString();
+        const res = /Version:\s*([^\s]+)\s*/.exec(text);
+        if (res) {
+            return res[1];
+        }
+    }
+    catch (e) {
+        throw new Error(`compilerVersion fail when run: ${cwd} version: ${e.message}`);
+    }
+    return undefined;
+}
+exports.compilerVersion = compilerVersion;
+function addSourceLocation(astRoot, basePath, curFileName) {
+    for (const fileName in astRoot) {
+        if (fileName === 'std') {
+            astRoot['std'] = _addSourceLocationProperty(astRoot['std'], 'std');
+        }
+        else {
+            const realFileName = fileName === 'stdin' ? curFileName : fileName;
+            const uri = (0, utils_1.path2uri)((0, path_1.join)(basePath, realFileName));
+            astRoot[uri] = _addSourceLocationProperty(astRoot[fileName], uri);
+            delete astRoot[fileName];
+        }
+    }
+    return astRoot;
+}
+function _addSourceLocationProperty(astObj, uri) {
+    if (!(typeof astObj === 'object')) {
+        return astObj;
+    }
+    for (const field in astObj) {
+        const value = astObj[field];
+        if (field === 'src') {
+            const matches = /:(\d+):(\d+):(\d+):(\d+)/.exec(value);
+            if (!matches) {
+                astObj.loc = null;
+            }
+            else {
+                astObj.loc = {
+                    source: uri,
+                    start: { line: parseInt(matches[1]), column: parseInt(matches[2]) },
+                    end: { line: parseInt(matches[3]), column: parseInt(matches[4]) },
+                };
+            }
+            delete astObj['src'];
+        }
+        else if (typeof value === 'object') {
+            _addSourceLocationProperty(value, uri);
+        }
+    }
+    return astObj;
+}
+function getOutputFilePath(baseDir, target) {
+    if (target == 'hex') {
+        return (0, path_1.join)(baseDir, `stdin_${target}.txt`);
+    }
+    else if (target === 'map') {
+        return (0, path_1.join)(baseDir, `stdin.${target}.json`);
+    }
+    else if (target === 'dbg') {
+        return (0, path_1.join)(baseDir, `stdin.${target}.json`);
+    }
+    else if (target === 'artifact') {
+        return (0, path_1.join)(baseDir, 'stdin.json');
+    }
+    return (0, path_1.join)(baseDir, `stdin_${target}.json`);
+}
+function getFullFilePath(relativePath, baseDir, curFileName) {
+    if (relativePath.endsWith('stdin')) {
+        return (0, path_1.join)(baseDir, curFileName); // replace 'stdin' with real current compiling file name.
+    }
+    if (relativePath === 'std') {
+        return 'std'; //
+    }
+    return (0, path_1.join)(baseDir, relativePath);
+}
+exports.getFullFilePath = getFullFilePath;
+function getConstructorDeclaration(mainContract) {
+    // explict constructor
+    if (mainContract['constructor']) {
+        return {
+            type: scrypt_ts_opcat_1.ABIEntityType.CONSTRUCTOR,
+            params: mainContract['constructor']['params'].map((p) => {
+                return { name: p['name'], type: p['type'] };
+            }),
+        };
+    }
+    else {
+        // implicit constructor
+        return {
+            type: scrypt_ts_opcat_1.ABIEntityType.CONSTRUCTOR,
+            params: mainContract['properties'].map((p) => {
+                return { name: p['name'].replace('this.', ''), type: p['type'] };
+            }),
+        };
+    }
+}
+function getStateProps(astRoot) {
+    const mainContract = astRoot['contracts'][astRoot['contracts'].length - 1];
+    if (mainContract && mainContract['properties']) {
+        return mainContract['properties']
+            .filter((p) => p.state)
+            .map((p) => {
+            return { name: p['name'].replace('this.', ''), type: p['type'] };
+        });
+    }
+    return [];
+}
+function getPublicFunctionDeclaration(mainContract) {
+    let pubIndex = 0;
+    const interfaces = mainContract['functions']
+        .filter((f) => f['visibility'] === 'Public')
+        .map((f) => {
+        const entity = {
+            type: scrypt_ts_opcat_1.ABIEntityType.FUNCTION,
+            name: f['name'],
+            index: f['nodeType'] === 'Constructor' ? undefined : pubIndex++,
+            params: f['params'].map((p) => {
+                return { name: p['name'], type: p['type'] };
+            }),
+        };
+        return entity;
+    });
+    return interfaces;
+}
+function getContractName(astRoot) {
+    const mainContract = astRoot['contracts'][astRoot['contracts'].length - 1];
+    if (!mainContract) {
+        return '';
+    }
+    return mainContract['name'] || '';
+}
+exports.getContractName = getContractName;
+function shortGenericType(genericType) {
+    const m = genericType.match(/__SCRYPT_(\w+)__/);
+    if (m) {
+        return m[1];
+    }
+    return genericType;
+}
+/**
+ *
+ * @param astRoot AST root node after main contract compilation
+ * @param typeResolver a Type Resolver
+ * @returns All function ABIs defined by the main contract, including constructors
+ */
+function getABIDeclaration(astRoot, typeResolver) {
+    const mainContract = astRoot['contracts'][astRoot['contracts'].length - 1];
+    if (!mainContract) {
+        return {
+            contract: '',
+            abi: [],
+        };
+    }
+    const interfaces = getPublicFunctionDeclaration(mainContract);
+    const constructorABI = getConstructorDeclaration(mainContract);
+    interfaces.push(constructorABI);
+    interfaces.forEach((abi) => {
+        abi.params = abi.params.map((param) => {
+            return Object.assign(param, {
+                type: typeResolver(param.type).finalType,
+            });
+        });
+    });
+    return {
+        contract: getContractName(astRoot),
+        abi: interfaces,
+    };
+}
+exports.getABIDeclaration = getABIDeclaration;
+/**
+ *
+ * @param astRoot AST root node after main contract compilation
+ * @param dependencyAsts AST root node after all dependency contract compilation
+ * @returns all defined structures of the main contract and dependent contracts
+ */
+function getStructDeclaration(astRoot, dependencyAsts) {
+    const allAst = [astRoot];
+    Object.keys(dependencyAsts).forEach((key) => {
+        allAst.push(dependencyAsts[key]);
+    });
+    return allAst
+        .map((ast) => {
+        return (ast['structs'] || []).map((s) => ({
+            name: s['name'],
+            params: s['fields'].map((p) => {
+                return { name: p['name'], type: p['type'] };
+            }),
+            genericTypes: s.genericTypes || [],
+        }));
+    })
+        .flat(1);
+}
+exports.getStructDeclaration = getStructDeclaration;
+/**
+ *
+ * @param astRoot AST root node after main contract compilation
+ * @param dependencyAsts AST root node after all dependency contract compilation
+ * @returns all defined Library of the main contract and dependent contracts
+ */
+function getLibraryDeclaration(astRoot, dependencyAsts) {
+    const allAst = [astRoot];
+    Object.keys(dependencyAsts).forEach((key) => {
+        if (key !== 'std') {
+            allAst.push(dependencyAsts[key]);
+        }
+    });
+    return allAst
+        .map((ast) => {
+        return (ast['contracts'] || [])
+            .filter((c) => c.nodeType == 'Library')
+            .map((c) => {
+            if (c['constructor']) {
+                return {
+                    name: c.name,
+                    params: c['constructor']['params'].map((p) => {
+                        return { name: `ctor.${p['name']}`, type: p['type'] };
+                    }),
+                    properties: c['properties'].map((p) => {
+                        return { name: p['name'], type: p['type'] };
+                    }),
+                    genericTypes: c.genericTypes || [],
+                };
+            }
+            else {
+                // implicit constructor
+                return {
+                    name: c.name,
+                    params: c['properties'].map((p) => {
+                        return { name: p['name'], type: p['type'] };
+                    }),
+                    properties: c['properties'].map((p) => {
+                        return { name: p['name'], type: p['type'] };
+                    }),
+                    genericTypes: c.genericTypes || [],
+                };
+            }
+        });
+    })
+        .flat(1);
+}
+exports.getLibraryDeclaration = getLibraryDeclaration;
+function getContractDeclaration(astRoot, dependencyAsts) {
+    const allAst = [astRoot];
+    Object.keys(dependencyAsts).forEach((key) => {
+        if (key !== 'std') {
+            allAst.push(dependencyAsts[key]);
+        }
+    });
+    return allAst
+        .map((ast) => {
+        return (ast['contracts'] || [])
+            .filter((c) => c.nodeType == 'Contract')
+            .map((c) => {
+            if (c['constructor']) {
+                return {
+                    name: c.name,
+                    params: c['constructor']['params'].map((p) => {
+                        return { name: `ctor.${p['name']}`, type: p['type'] };
+                    }),
+                    properties: c['properties'].map((p) => {
+                        return { name: p['name'], type: p['type'] };
+                    }),
+                    genericTypes: c.genericTypes || [],
+                };
+            }
+            else {
+                // implicit constructor
+                return {
+                    name: c.name,
+                    params: c['properties'].map((p) => {
+                        return { name: p['name'], type: p['type'] };
+                    }),
+                    properties: c['properties'].map((p) => {
+                        return { name: p['name'], type: p['type'] };
+                    }),
+                    genericTypes: c.genericTypes || [],
+                };
+            }
+        });
+    })
+        .flat(1);
+}
+exports.getContractDeclaration = getContractDeclaration;
+/**
+ *
+ * @param astRoot AST root node after main contract compilation
+ * @param dependencyAsts AST root node after all dependency contract compilation
+ * @returns all defined type aliaes of the main contract and dependent contracts
+ */
+function getAliasDeclaration(astRoot, dependencyAsts) {
+    const allAst = [astRoot];
+    Object.keys(dependencyAsts).forEach((key) => {
+        allAst.push(dependencyAsts[key]);
+    });
+    return allAst
+        .map((ast) => {
+        return (ast['alias'] || []).map((s) => ({
+            name: s['alias'],
+            type: s['type'],
+        }));
+    })
+        .flat(1);
+}
+exports.getAliasDeclaration = getAliasDeclaration;
+/**
+ *
+ * @param astRoot AST root node after main contract compilation
+ * @param dependencyAsts AST root node after all dependency contract compilation
+ * @returns all defined static const int literal of the main contract and dependent contracts
+ */
+function getStaticDeclaration(astRoot, dependencyAsts) {
+    const allAst = [astRoot];
+    Object.keys(dependencyAsts).forEach((key) => {
+        allAst.push(dependencyAsts[key]);
+    });
+    return allAst
+        .map((ast) => {
+        return (ast['contracts'] || []).map((contract) => {
+            return (contract.statics || []).map((node) => {
+                return {
+                    const: node.const,
+                    name: `${contract.name}.${node.name}`,
+                    type: node.type,
+                    value: resolveConstValue(node),
+                };
+            });
+        });
+    })
+        .flat(Infinity)
+        .flat(1)
+        .filter((item) => item.const && item.value);
+}
+exports.getStaticDeclaration = getStaticDeclaration;
+function getRelatedInformation(message, srcDir, sourceFileName) {
+    const relatedInformation = [];
+    let result;
+    while ((result = RELATED_INFORMATION_REG.exec(message))) {
+        const relatedFilePath = result.groups.filePath;
+        if (relatedFilePath === 'null')
+            continue;
+        const fullFilePath = getFullFilePath(relatedFilePath, srcDir, sourceFileName);
+        const line = parseInt(result.groups?.line || '-1');
+        const column = parseInt(result.groups?.column || '-1');
+        relatedInformation.push({
+            filePath: fullFilePath,
+            position: [
+                {
+                    line: line,
+                    column: column,
+                },
+                {
+                    line: parseInt(result.groups?.line1 || '-1'),
+                    column: parseInt(result.groups?.column1 || '-1'),
+                },
+            ],
+            message: '',
+        });
+        message = message.replace(/([^\s]+):(\d+):(\d+):(\d+):(\d+)/, '');
+    }
+    return {
+        relatedInformation,
+        message,
+    };
+}
+function getErrorsAndWarnings(output, srcDir, sourceFileName) {
+    const warnings = [...output.matchAll(WARNING_REG)].map((match) => {
+        const filePath = match.groups?.filePath || '';
+        const origin_message = match.groups?.message || '';
+        const { message, relatedInformation } = getRelatedInformation(origin_message, srcDir, sourceFileName);
+        return {
+            type: CompileErrorType.Warning,
+            filePath: getFullFilePath(filePath, srcDir, sourceFileName),
+            position: [
+                {
+                    line: parseInt(match.groups?.line || '-1'),
+                    column: parseInt(match.groups?.column || '-1'),
+                },
+                {
+                    line: parseInt(match.groups?.line1 || '-1'),
+                    column: parseInt(match.groups?.column1 || '-1'),
+                },
+            ],
+            message: message,
+            relatedInformation: relatedInformation,
+        };
+    });
+    const INTERNAL_ERR = output.match(INTERNAL_ERR_REG);
+    if (INTERNAL_ERR) {
+        const errors = [
+            {
+                type: CompileErrorType.InternalError,
+                filePath: getFullFilePath('stdin', srcDir, sourceFileName),
+                message: `Compiler internal error: ${INTERNAL_ERR.groups?.message || ''}`,
+                position: [
+                    {
+                        line: 1,
+                        column: 1,
+                    },
+                    {
+                        line: 1,
+                        column: 1,
+                    },
+                ],
+                relatedInformation: [],
+            },
+        ];
+        return new CompileResult(errors, warnings);
+    }
+    else if (output.includes('Syntax error:')) {
+        const syntaxErrors = [...output.matchAll(SYNTAX_ERR_REG)].map((match) => {
+            const filePath = match.groups?.filePath || '';
+            const unexpected = match.groups?.unexpected || '';
+            const expecting = match.groups?.expecting || '';
+            const origin_message = match.groups?.message || `unexpected ${unexpected}\nexpecting ${expecting}`;
+            const { message, relatedInformation } = getRelatedInformation(origin_message, srcDir, sourceFileName);
+            return {
+                type: CompileErrorType.SyntaxError,
+                filePath: getFullFilePath(filePath, srcDir, sourceFileName),
+                position: [
+                    {
+                        line: parseInt(match.groups?.line || '-1'),
+                        column: parseInt(match.groups?.column || '-1'),
+                    },
+                ],
+                message: message,
+                unexpected,
+                expecting,
+                relatedInformation: relatedInformation,
+            };
+        });
+        return new CompileResult(syntaxErrors, warnings);
+    }
+    else {
+        const semanticErrors = [...output.matchAll(SEMANTIC_ERR_REG)].map((match) => {
+            const origin_message = match.groups?.message || '';
+            const filePath = match.groups?.filePath || '';
+            const { message, relatedInformation } = getRelatedInformation(origin_message, srcDir, sourceFileName);
+            return {
+                type: CompileErrorType.SemanticError,
+                filePath: getFullFilePath(filePath, srcDir, sourceFileName),
+                position: [
+                    {
+                        line: parseInt(match.groups?.line || '-1'),
+                        column: parseInt(match.groups?.column || '-1'),
+                    },
+                    {
+                        line: parseInt(match.groups?.line1 || '-1'),
+                        column: parseInt(match.groups?.column1 || '-1'),
+                    },
+                ],
+                message: message,
+                relatedInformation: relatedInformation,
+            };
+        });
+        return new CompileResult(semanticErrors, warnings);
+    }
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function resolveConstValue(node) {
+    if (node.expr.nodeType === 'IntLiteral') {
+        return node.expr.value.toString(10);
+    }
+    else if (node.type === 'int' && node.expr.nodeType === 'Variable') {
+        return node.expr.name;
+    }
+    else if (node.type === 'int' &&
+        node.expr.nodeType === 'BinaryExpr' &&
+        node.expr.name === 'Dot') {
+        return `${node.expr.lExpr.name}.${node.expr.rExpr.name}`;
+    }
+    return undefined;
+}
+function parserAst(result, ast, srcDir, sourceFileName, sourcePath) {
+    const allAst = addSourceLocation(ast, srcDir, sourceFileName);
+    const sourceUri = (0, utils_1.path2uri)(sourcePath);
+    result.file = sourcePath;
+    result.ast = allAst[sourceUri];
+    delete allAst[sourceUri];
+    result.dependencyAsts = allAst;
+    const alias = getAliasDeclaration(result.ast, allAst);
+    const structs = getStructDeclaration(result.ast, allAst);
+    const library = getLibraryDeclaration(result.ast, allAst);
+    const statics = getStaticDeclaration(result.ast, allAst);
+    result.contracts = getContractDeclaration(result.ast, allAst);
+    const typeResolver = (0, resolver_1.buildTypeResolver)(getContractName(result.ast), alias, structs, library, result.contracts, statics);
+    result.alias = alias.map((a) => ({
+        name: a.name,
+        type: typeResolver(a.type).finalType,
+    }));
+    result.structs = structs.map((a) => ({
+        name: a.name,
+        params: a.params.map((p) => ({ name: p.name, type: typeResolver(p.type).finalType })),
+        genericTypes: a.genericTypes.map((t) => shortGenericType(t)),
+    }));
+    result.library = library.map((a) => ({
+        name: a.name,
+        params: a.params.map((p) => ({ name: p.name, type: typeResolver(p.type).finalType })),
+        properties: a.properties.map((p) => ({ name: p.name, type: typeResolver(p.type).finalType })),
+        genericTypes: a.genericTypes.map((t) => shortGenericType(t)),
+    }));
+    result.statics = statics.map((s) => Object.assign({ ...s }, {
+        type: typeResolver(s.type).finalType,
+    }));
+    const { contract: name, abi } = getABIDeclaration(result.ast, typeResolver);
+    result.stateProps = getStateProps(result.ast).map((p) => ({
+        name: p.name,
+        type: typeResolver(p.type).finalType,
+    }));
+    result.abi = abi;
+    result.contract = name;
+}
+/**
+ * @deprecated use `--hex` when compiling
+ * @param result
+ * @param asmObj
+ * @param settings
+ * @param srcDir
+ * @param sourceFileName
+ */
+function parserASM(result, asmObj, settings, srcDir, sourceFileName) {
+    const sources = asmObj['sources'];
+    if (settings.debug) {
+        Object.assign(result, {
+            file: result.file,
+            sources: asmObj['sources'].map((source) => getFullFilePath(source, srcDir, sourceFileName)),
+            sourceMap: asmObj['output'].map((item) => item.src),
+        });
+    }
+    result.hex = settings.hex ? asmObj['output'].map((item) => item.hex).join('') : '';
+    result.asm = asmObj['output'].map((item) => {
+        if (!settings.debug) {
+            return {
+                opcode: item.opcode,
+            };
+        }
+        const match = exports.SOURCE_REG.exec(item.src);
+        if (match && match.groups) {
+            const fileIndex = parseInt(match.groups.fileIndex);
+            let debugInfo;
+            const tagStr = match.groups.tagStr;
+            const m = /^(\w+)\.(\w+):(\d)(#(?<context>.+))?$/.exec(tagStr);
+            if (m && m.groups) {
+                debugInfo = {
+                    contract: m[1],
+                    func: m[2],
+                    tag: m[3] == '0' ? DebugModeTag.FuncStart : DebugModeTag.FuncEnd,
+                    context: m.groups.context,
+                };
+            }
+            else if (/loop:0/.test(tagStr)) {
+                debugInfo = {
+                    contract: '',
+                    func: '',
+                    tag: DebugModeTag.LoopStart,
+                    context: '',
+                };
+            }
+            const pos = sources[fileIndex]
+                ? {
+                    file: sources[fileIndex]
+                        ? getFullFilePath(sources[fileIndex], srcDir, sourceFileName)
+                        : '',
+                    line: sources[fileIndex] ? parseInt(match.groups.line) : -1,
+                    endLine: sources[fileIndex] ? parseInt(match.groups.endLine) : -1,
+                    column: sources[fileIndex] ? parseInt(match.groups.col) : -1,
+                    endColumn: sources[fileIndex] ? parseInt(match.groups.endCol) : -1,
+                }
+                : undefined;
+            return {
+                opcode: item.opcode,
+                stack: item.stack,
+                topVars: item.topVars || [],
+                pos: pos,
+                debugInfo,
+            };
+        }
+        throw new Error('Compile Failed: Asm output parsing Error!');
+    });
+    if (settings.debug) {
+        result.autoTypedVars = asmObj['autoTypedVars'].map((item) => {
+            const match = exports.SOURCE_REG.exec(item.src);
+            let fileIndex = -1;
+            if (match && match.groups) {
+                fileIndex = parseInt(match.groups.fileIndex);
+            }
+            const pos = fileIndex > -1 && sources[fileIndex]
+                ? {
+                    file: sources[fileIndex]
+                        ? getFullFilePath(sources[fileIndex], srcDir, sourceFileName)
+                        : '',
+                    line: sources[fileIndex] ? parseInt(match.groups.line) : -1,
+                    endLine: sources[fileIndex] ? parseInt(match.groups.endLine) : -1,
+                    column: sources[fileIndex] ? parseInt(match.groups.col) : -1,
+                    endColumn: sources[fileIndex] ? parseInt(match.groups.endCol) : -1,
+                }
+                : undefined;
+            return {
+                name: item.name,
+                type: item.type,
+                pos: pos,
+            };
+        });
+    }
+}
+function doClean(settings, outputFiles, outputDir) {
+    if (settings.stdout || settings.outputToFiles || settings.sourceMap) {
+        return;
+    }
+    try {
+        Object.keys(outputFiles).forEach((outputType) => {
+            const file = outputFiles[outputType];
+            if ((0, fs_1.existsSync)(file)) {
+                (0, fs_1.unlinkSync)(file);
+            }
+        });
+        (0, rimraf_1.rimrafSync)(outputDir);
+    }
+    catch (error) {
+        console.error('clean compiler output files failed!', error);
+    }
+    // console.log('compile time spent: ', Date.now() - st)
+}
+function compileContract(file, options) {
+    options = Object.assign({
+        out: (0, path_1.dirname)(file),
+        sourceMap: false,
+        artifact: false,
+        optimize: true,
+    }, options);
+    if (!(0, fs_1.existsSync)(file)) {
+        throw `file ${file} not exists!`;
+    }
+    if (!(0, fs_1.existsSync)(options.out)) {
+        (0, fs_1.mkdirSync)(options.out);
+    }
+    const result = compile({ path: file }, {
+        artifact: options.artifact,
+        outputDir: options.out,
+        sourceMap: options.sourceMap,
+        optimize: options.optimize,
+        cmdPrefix: (0, findCompiler_1.findCompiler)(),
+    });
+    return result;
+}
+exports.compileContract = compileContract;
+function compileContractAsync(file, options) {
+    options = Object.assign({
+        out: (0, path_1.join)(__dirname, '..', 'out'),
+        sourceMap: false,
+        artifact: false,
+        optimize: true,
+    }, options);
+    if (!(0, fs_1.existsSync)(file)) {
+        throw `file ${file} not exists!`;
+    }
+    if (!(0, fs_1.existsSync)(options.out)) {
+        (0, fs_1.mkdirSync)(options.out);
+    }
+    return compileAsync({ path: file }, {
+        artifact: options.artifact,
+        outputDir: options.out,
+        sourceMap: options.sourceMap,
+        optimize: options.optimize,
+        hex: true,
+        cmdPrefix: (0, findCompiler_1.findCompiler)(),
+    });
+}
+exports.compileContractAsync = compileContractAsync;
+//# sourceMappingURL=compilerWrapper.js.map