@theqrl/hypc 0.2.0 → 0.3.1

package/formatters.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.formatFatalError = void 0;
+exports.formatFatalError = formatFatalError;
 function formatFatalError(message) {
     return JSON.stringify({
         errors: [
@@ -8,10 +8,9 @@ function formatFatalError(message) {
                 type: 'JSONError',
                 component: 'hypcjs',
                 severity: 'error',
-                message: message,
+                message,
                 formattedMessage: 'Error: ' + message
             }
         ]
     });
 }
-exports.formatFatalError = formatFatalError;

package/hypc.js

@@ -16,13 +16,23 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : 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 __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -41,16 +51,15 @@ const originalUncaughtExceptionListeners = process.listeners('uncaughtException'
 process.removeAllListeners('uncaughtException');
 const program = new commander.Command();
 const commanderParseInt = function (value) {
-    const parsedValue = parseInt(value, 10);
-    if (isNaN(parsedValue)) {
+    if (!/^\d+$/.test(value)) {
         throw new commander.InvalidArgumentError('Not a valid integer.');
     }
-    return parsedValue;
+    return parseInt(value, 10);
 };
 program.name('hypcjs');
-program.version(index_1.default.version());
+program.version(index_1.default.version(), '-V, --version', 'Show version and exit.');
 program
-    .option('--version', 'Show version and exit.')
+    .argument('[files...]', 'Source files to compile.')
     .option('--optimize', 'Enable bytecode optimizer.', false)
     .option('--optimize-runs <optimize-runs>', 'The number of runs specifies roughly how often each opcode of the deployed code will be executed across the lifetime of the contract. ' +
     'Lower values will optimize more for initial deployment cost, higher values will optimize more for high-frequency usage.', commanderParseInt)
@@ -73,11 +82,43 @@ function abort(msg) {
     console.error(msg || 'Error occurred');
     process.exit(1);
 }
+function realPathIfExists(filePath) {
+    try {
+        return fs.realpathSync(filePath);
+    }
+    catch (e) {
+        return path.resolve(filePath);
+    }
+}
+// As in hypc, imports may only be read from the base path (the working directory by default),
+// the include paths and the directories of the files given on the command line. Symlinks are
+// resolved before the check, so a link cannot point outside these directories.
+// Without a base path the working directory is not allowed when it is the root of the filesystem
+// (or of a drive on Windows), since that would make every readable file importable.
+function defaultAllowedDirectories() {
+    if (options.basePath) {
+        return [options.basePath];
+    }
+    const workingDirectory = realPathIfExists('.');
+    return path.parse(workingDirectory).root === workingDirectory ? [] : [workingDirectory];
+}
+const allowedDirectories = defaultAllowedDirectories()
+    .concat(options.includePath || [], files.map((file) => path.dirname(file)))
+    .map(realPathIfExists);
+function isInsideAllowedDirectory(filePath) {
+    return allowedDirectories.some((directory) => {
+        const relativePath = path.relative(directory, filePath);
+        return relativePath === '' || (relativePath.split(path.sep)[0] !== '..' && !path.isAbsolute(relativePath));
+    });
+}
 function readFileCallback(sourcePath) {
     const prefixes = [options.basePath ? options.basePath : ''].concat(options.includePath ? options.includePath : []);
     for (const prefix of prefixes) {
         const prefixedSourcePath = (prefix ? prefix + '/' : '') + sourcePath;
         if (fs.existsSync(prefixedSourcePath)) {
+            if (!isInsideAllowedDirectory(fs.realpathSync(prefixedSourcePath))) {
+                return { error: 'File outside of allowed directories.' };
+            }
             try {
                 return { contents: fs.readFileSync(prefixedSourcePath).toString('utf8') };
             }
@@ -117,10 +158,25 @@ function makeSourcePathRelativeIfPossible(sourcePath) {
     return withUnixPathSeparators(absoluteSourcePath);
 }
 function toFormattedJson(input) {
-    return JSON.stringify(input, null, program.prettyJson ? 4 : 0);
+    return JSON.stringify(input, null, options.prettyJson ? 4 : 0);
 }
+// Input that is not valid JSON is returned as it is, so that the compiler reports it.
 function reformatJsonIfRequested(inputJson) {
-    return (program.prettyJson ? toFormattedJson(JSON.parse(inputJson)) : inputJson);
+    if (!options.prettyJson) {
+        return inputJson;
+    }
+    try {
+        return toFormattedJson(JSON.parse(inputJson));
+    }
+    catch (e) {
+        return inputJson;
+    }
+}
+// Diagnostics go to stderr, so that stdout carries only the compiler output.
+function verbose(message) {
+    if (options.verbose) {
+        console.error(message);
+    }
 }
 let callbacks;
 if (options.basePath || !options.standardJson) {
@@ -128,20 +184,16 @@ if (options.basePath || !options.standardJson) {
 }
 if (options.standardJson) {
     const input = fs.readFileSync(process.stdin.fd).toString('utf8');
-    if (program.verbose) {
-        console.log('>>> Compiling:\n' + reformatJsonIfRequested(input) + '\n');
-    }
+    verbose('>>> Compiling:\n' + reformatJsonIfRequested(input) + '\n');
     let output = reformatJsonIfRequested(index_1.default.compile(input, callbacks));
     try {
         if (smtsolver_1.default.availableSolvers.length === 0) {
-            console.log('>>> Cannot retry compilation with SMT because there are no SMT solvers available.');
+            verbose('>>> Cannot retry compilation with SMT because there are no SMT solvers available.');
         }
         else {
             const inputJSON = smtchecker_1.default.handleSMTQueries(JSON.parse(input), JSON.parse(output), smtsolver_1.default.smtSolver, smtsolver_1.default.availableSolvers[0]);
             if (inputJSON) {
-                if (program.verbose) {
-                    console.log('>>> Retrying compilation with SMT:\n' + toFormattedJson(inputJSON) + '\n');
-                }
+                verbose('>>> Retrying compilation with SMT:\n' + toFormattedJson(inputJSON) + '\n');
                 output = reformatJsonIfRequested(index_1.default.compile(JSON.stringify(inputJSON), callbacks));
             }
         }
@@ -160,9 +212,7 @@ if (options.standardJson) {
         outputJSON.errors.push(addError);
         output = toFormattedJson(outputJSON);
     }
-    if (program.verbose) {
-        console.log('>>> Compilation result:');
-    }
+    verbose('>>> Compilation result:');
     console.log(output);
     process.exit(0);
 }
@@ -207,11 +257,9 @@ const cliInput = {
             }
         }
     },
-    sources: sources
+    sources
 };
-if (program.verbose) {
-    console.log('>>> Compiling:\n' + toFormattedJson(cliInput) + '\n');
-}
+verbose('>>> Compiling:\n' + toFormattedJson(cliInput) + '\n');
 const output = JSON.parse(index_1.default.compile(JSON.stringify(cliInput), callbacks));
 let hasError = false;
 if (!output) {
@@ -232,16 +280,24 @@ else if (output.errors) {
 fs.mkdirSync(destination, { recursive: true });
 function writeFile(file, content) {
     file = path.join(destination, file);
-    fs.writeFile(file, content, function (err) {
-        if (err) {
-            console.error('Failed to write ' + file + ': ' + err);
-        }
-    });
+    try {
+        fs.writeFileSync(file, content);
+    }
+    catch (err) {
+        console.error('Failed to write ' + file + ': ' + err);
+    }
 }
+// Output names replace ':', '.', '/' and '\' with '_', so different contracts can map to one name.
+const outputNames = new Map();
 for (const fileName in output.contracts) {
     for (const contractName in output.contracts[fileName]) {
         let contractFileName = fileName + ':' + contractName;
         contractFileName = contractFileName.replace(/[:./\\]/g, '_');
+        const previous = outputNames.get(contractFileName);
+        if (previous) {
+            console.error(`Warning: ${previous} and ${fileName}:${contractName} both write ${contractFileName}; the output of ${fileName}:${contractName} replaces the other.`);
+        }
+        outputNames.set(contractFileName, `${fileName}:${contractName}`);
         if (options.bin) {
             writeFile(contractFileName + '.bin', output.contracts[fileName][contractName].qrvm.bytecode.object);
         }