@theqrl/hypc 0.0.2

package/bindings/core.js

@@ -0,0 +1,116 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupCore = void 0;
+const helpers_1 = require("./helpers");
+const translate_1 = __importDefault(require("../translate"));
+const helpers_2 = require("../common/helpers");
+function setupCore(hypJson) {
+    const core = {
+        alloc: bindAlloc(hypJson),
+        license: bindLicense(hypJson),
+        version: bindVersion(hypJson),
+        reset: bindReset(hypJson)
+    };
+    const helpers = {
+        addFunction: unboundAddFunction.bind(this, hypJson),
+        removeFunction: unboundRemoveFunction.bind(this, hypJson),
+        copyFromCString: unboundCopyFromCString.bind(this, hypJson),
+        copyToCString: unboundCopyToCString.bind(this, hypJson, core.alloc),
+        // @ts-ignore
+        versionToSemver: versionToSemver(core.version())
+    };
+    return {
+        ...core,
+        ...helpers
+    };
+}
+exports.setupCore = setupCore;
+/**********************
+ * Core Functions
+ **********************/
+/**
+ * Returns a binding to the hyperion_alloc function.
+ *
+ * @param hypJson The Emscripten compiled Hyperion object.
+ */
+function bindAlloc(hypJson) {
+    const allocBinding = (0, helpers_1.bindHypcMethod)(hypJson, 'hyperion_alloc', 'number', ['number'], null);
+    // the fallback malloc is not a cwrap function and should just be returned
+    // directly in-case the alloc binding could not happen.
+    if ((0, helpers_2.isNil)(allocBinding)) {
+        return hypJson._malloc;
+    }
+    return allocBinding;
+}
+/**
+ * Returns a binding to the hyperion_version method.
+ *
+ * @param hypJson The Emscripten compiled Hyperion object.
+ */
+function bindVersion(hypJson) {
+    return (0, helpers_1.bindHypcMethodWithFallbackFunc)(hypJson, 'hyperion_version', 'string', [], 'version');
+}
+function versionToSemver(version) {
+    return translate_1.default.versionToSemver.bind(this, version);
+}
+/**
+ * Returns a binding to the hyperion_license method.
+ *
+ * If the current hypJson version < 0.4.14 then this will bind an empty function.
+ *
+ * @param hypJson The Emscripten compiled Hyperion object.
+ */
+function bindLicense(hypJson) {
+    return (0, helpers_1.bindHypcMethodWithFallbackFunc)(hypJson, 'hyperion_license', 'string', [], 'license', () => {
+    });
+}
+/**
+ * Returns a binding to the hyperion_reset method.
+ *
+ * @param hypJson The Emscripten compiled Hyperion object.
+ */
+function bindReset(hypJson) {
+    return (0, helpers_1.bindHypcMethod)(hypJson, 'hyperion_reset', null, [], null);
+}
+/**********************
+ * Helpers Functions
+ **********************/
+/**
+ * Copy to a C string.
+ *
+ * Allocates memory using hypc's allocator.
+ *
+ * After 0.6.0:
+ *   The duty is on hypc-js to free these pointers. We accomplish that by calling `reset` at the end.
+ *
+ * @param hypJson The Emscripten compiled Hyperion object.
+ * @param alloc The memory allocation function.
+ * @param str The source string being copied to a C string.
+ * @param ptr The pointer location where the C string will be set.
+ */
+function unboundCopyToCString(hypJson, alloc, str, ptr) {
+    const length = hypJson.lengthBytesUTF8(str);
+    const buffer = alloc(length + 1);
+    hypJson.stringToUTF8(str, buffer, length + 1);
+    hypJson.setValue(ptr, buffer, '*');
+}
+/**
+ * Wrapper over Emscripten's C String copying function (which can be different
+ * on different versions).
+ *
+ * @param hypJson The Emscripten compiled Hyperion object.
+ * @param ptr The pointer location where the C string will be referenced.
+ */
+function unboundCopyFromCString(hypJson, ptr) {
+    const copyFromCString = hypJson.UTF8ToString || hypJson.Pointer_stringify;
+    return copyFromCString(ptr);
+}
+function unboundAddFunction(hypJson, func, signature) {
+    return (hypJson.addFunction || hypJson.Runtime.addFunction)(func, signature);
+}
+function unboundRemoveFunction(hypJson, ptr) {
+    return (hypJson.removeFunction || hypJson.Runtime.removeFunction)(ptr);
+}

package/bindings/helpers.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSupportedMethods = exports.bindHypcMethodWithFallbackFunc = exports.bindHypcMethod = void 0;
+const helpers_1 = require("../common/helpers");
+function bindHypcMethod(hypJson, method, returnType, args, defaultValue) {
+    if ((0, helpers_1.isNil)(hypJson[`_${method}`]) && defaultValue !== undefined) {
+        return defaultValue;
+    }
+    return hypJson.cwrap(method, returnType, args);
+}
+exports.bindHypcMethod = bindHypcMethod;
+function bindHypcMethodWithFallbackFunc(hypJson, method, returnType, args, fallbackMethod, finalFallback = undefined) {
+    const methodFunc = bindHypcMethod(hypJson, method, returnType, args, null);
+    if (!(0, helpers_1.isNil)(methodFunc)) {
+        return methodFunc;
+    }
+    return bindHypcMethod(hypJson, fallbackMethod, returnType, args, finalFallback);
+}
+exports.bindHypcMethodWithFallbackFunc = bindHypcMethodWithFallbackFunc;
+function getSupportedMethods(hypJson) {
+    return {
+        licenseSupported: anyMethodExists(hypJson, 'hyperion_license'),
+        versionSupported: anyMethodExists(hypJson, 'hyperion_version'),
+        allocSupported: anyMethodExists(hypJson, 'hyperion_alloc'),
+        resetSupported: anyMethodExists(hypJson, 'hyperion_reset'),
+        compileJsonSupported: anyMethodExists(hypJson, 'compileJSON'),
+        compileJsonMultiSupported: anyMethodExists(hypJson, 'compileJSONMulti'),
+        compileJsonCallbackSuppported: anyMethodExists(hypJson, 'compileJSONCallback'),
+        compileJsonStandardSupported: anyMethodExists(hypJson, 'compileStandard', 'hyperion_compile')
+    };
+}
+exports.getSupportedMethods = getSupportedMethods;
+function anyMethodExists(hypJson, ...names) {
+    return names.some(name => !(0, helpers_1.isNil)(hypJson[`_${name}`]));
+}

package/bindings/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("./core");
+const helpers_1 = require("./helpers");
+const compile_1 = require("./compile");
+function setupBindings(hypJson) {
+    const coreBindings = (0, core_1.setupCore)(hypJson);
+    const compileBindings = (0, compile_1.setupCompile)(hypJson, coreBindings);
+    const methodFlags = (0, helpers_1.getSupportedMethods)(hypJson);
+    return {
+        methodFlags,
+        coreBindings,
+        compileBindings
+    };
+}
+exports.default = setupBindings;

package/build/clean.js

@@ -0,0 +1,6 @@
+const fs = require('fs');
+const path = require('path');
+const distFolder = path.join(__dirname, 'dist');
+if (fs.existsSync(distFolder)) {
+    fs.rmdirSync(distFolder);
+}

package/build/pack-publish-block.js

@@ -0,0 +1,10 @@
+// This is meant to run in a hook before npm pack.
+// Reporting an error from the hook interrupts the command.
+if (process.env.BYPASS_SAFETY_CHECK === 'false' || process.env.BYPASS_SAFETY_CHECK === undefined) {
+    console.error('Run `npm run build:tarball` or `npm run publish:tarball` to pack or publish the package');
+    process.exit(1);
+}
+else if (process.env.BYPASS_SAFETY_CHECK !== 'true') {
+    console.error('Invalid value of the BYPASS_SAFETY_CHECK variable. Must be "true", "false" or unset.');
+    process.exit(1);
+}

package/build/postbuild.js

@@ -0,0 +1,3 @@
+const fs = require('fs');
+const path = require('path');
+fs.chmodSync(path.join(__dirname, '../dist', 'hypc.js'), '755');

package/common/helpers.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isObject = exports.isNil = void 0;
+/**
+ * Returns true if and only if the value is null or undefined.
+ *
+ * @param value
+ */
+function isNil(value) {
+    // Uses == over === which compares both null and undefined.
+    return value == null;
+}
+exports.isNil = isNil;
+/**
+ * Returns true if and only if the value is an object and not an array.
+ *
+ * @param value
+ */
+function isObject(value) {
+    // typeof [] will result in an 'object' so this additionally uses Array.isArray
+    // to confirm it's just an object.
+    return typeof value === 'object' && !Array.isArray(value);
+}
+exports.isObject = isObject;

package/common/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/contractA_hyp_A.bin

@@ -0,0 +1 @@
+6080604052348015600e575f80fd5b50603e80601a5f395ff3fe60806040525f80fdfea26469706673582212207da9777c17d9abc5309ba89332ae703efba54bf7fb9c290d475d6c0f7cb7a6c86468797063430000020033

package/contractB_hyp_B.bin

@@ -0,0 +1 @@
+6080604052348015600e575f80fd5b50603e80601a5f395ff3fe60806040525f80fdfea264697066735822122019ceaad2fc0893d39b61042424757a67bf6723d77172da4c38279007c2723bbf6468797063430000020033

package/downloadCurrentVersion.js

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+"use strict";
+// This is used to download the correct binary version
+// as part of the prepublish step.
+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 });
+const fs = __importStar(require("fs"));
+const follow_redirects_1 = require("follow-redirects");
+const memorystream_1 = __importDefault(require("memorystream"));
+const js_sha3_1 = require("js-sha3");
+const pkg = require('./package.json');
+function getVersionList(cb) {
+    console.log('Retrieving available version list...');
+    const mem = new memorystream_1.default(null, { readable: false });
+    follow_redirects_1.https.get('https://binaries.theqrl.org/bin/list.json', function (response) {
+        if (response.statusCode !== 200) {
+            console.log('Error downloading file: ' + response.statusCode);
+            process.exit(1);
+        }
+        response.pipe(mem);
+        response.on('end', function () {
+            cb(mem.toString());
+        });
+    });
+}
+function downloadBinary(outputName, version, expectedHash) {
+    console.log('Downloading version', version);
+    // Remove if existing
+    if (fs.existsSync(outputName)) {
+        fs.unlinkSync(outputName);
+    }
+    process.on('SIGINT', function () {
+        console.log('Interrupted, removing file.');
+        fs.unlinkSync(outputName);
+        process.exit(1);
+    });
+    const file = fs.createWriteStream(outputName, { encoding: 'binary' });
+    follow_redirects_1.https.get('https://binaries.theqrl.org/bin/' + version, function (response) {
+        if (response.statusCode !== 200) {
+            console.log('Error downloading file: ' + response.statusCode);
+            process.exit(1);
+        }
+        response.pipe(file);
+        file.on('finish', function () {
+            file.close(function () {
+                const hash = '0x' + (0, js_sha3_1.keccak256)(fs.readFileSync(outputName, { encoding: 'binary' }));
+                if (expectedHash !== hash) {
+                    console.log('Hash mismatch: ' + expectedHash + ' vs ' + hash);
+                    process.exit(1);
+                }
+                console.log('Done.');
+            });
+        });
+    });
+}
+console.log('Downloading correct hyperion binary...');
+getVersionList(function (list) {
+    list = JSON.parse(list);
+    const wanted = pkg.version.match(/^(\d+\.\d+\.\d+)$/)[1];
+    const releaseFileName = list.releases[wanted];
+    const expectedFile = list.builds.filter(function (entry) { return entry.path === releaseFileName; })[0];
+    if (!expectedFile) {
+        console.log('Version list is invalid or corrupted?');
+        process.exit(1);
+    }
+    const expectedHash = expectedFile.keccak256;
+    downloadBinary('hypjson.js', releaseFileName, expectedHash);
+});

package/formatters.js

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

package/hypc.js

@@ -0,0 +1,259 @@
+#!/usr/bin/env node
+"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 });
+const commander = __importStar(require("commander"));
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const index_1 = __importDefault(require("./index"));
+const smtchecker_1 = __importDefault(require("./smtchecker"));
+const smtsolver_1 = __importDefault(require("./smtsolver"));
+// hold on to any exception handlers that existed prior to this script running, we'll be adding them back at the end
+const originalUncaughtExceptionListeners = process.listeners('uncaughtException');
+// FIXME: remove annoying exception catcher of Emscripten
+//        see https://github.com/chriseth/browser-solidity/issues/167
+process.removeAllListeners('uncaughtException');
+const program = new commander.Command();
+const commanderParseInt = function (value) {
+    const parsedValue = parseInt(value, 10);
+    if (isNaN(parsedValue)) {
+        throw new commander.InvalidArgumentError('Not a valid integer.');
+    }
+    return parsedValue;
+};
+program.name('hypcjs');
+program.version(index_1.default.version());
+program
+    .option('--version', 'Show version and exit.')
+    .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)
+    .option('--bin', 'Binary of the contracts in hex.')
+    .option('--abi', 'ABI of the contracts.')
+    .option('--standard-json', 'Turn on Standard JSON Input / Output mode.')
+    .option('--base-path <path>', 'Root of the project source tree. ' +
+    'The import callback will attempt to interpret all import paths as relative to this directory.')
+    .option('--include-path <path...>', 'Extra source directories available to the import callback. ' +
+    'When using a package manager to install libraries, use this option to specify directories where packages are installed. ' +
+    'Can be used multiple times to provide multiple locations.')
+    .option('-o, --output-dir <output-directory>', 'Output directory for the contracts.')
+    .option('-p, --pretty-json', 'Pretty-print all JSON output.', false)
+    .option('-v, --verbose', 'More detailed console output.', false);
+program.parse(process.argv);
+const options = program.opts();
+const files = program.args;
+const destination = options.outputDir || '.';
+function abort(msg) {
+    console.error(msg || 'Error occurred');
+    process.exit(1);
+}
+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)) {
+            try {
+                return { contents: fs.readFileSync(prefixedSourcePath).toString('utf8') };
+            }
+            catch (e) {
+                return { error: 'Error reading ' + prefixedSourcePath + ': ' + e };
+            }
+        }
+    }
+    return { error: 'File not found inside the base path or any of the include paths.' };
+}
+function withUnixPathSeparators(filePath) {
+    // On UNIX-like systems forward slashes in paths are just a part of the file name.
+    if (os.platform() !== 'win32') {
+        return filePath;
+    }
+    return filePath.replace(/\\/g, '/');
+}
+function makeSourcePathRelativeIfPossible(sourcePath) {
+    const absoluteBasePath = (options.basePath ? path.resolve(options.basePath) : path.resolve('.'));
+    const absoluteIncludePaths = (options.includePath
+        ? options.includePath.map((prefix) => { return path.resolve(prefix); })
+        : []);
+    // Compared to base path stripping logic in hypc this is much simpler because path.resolve()
+    // handles symlinks correctly (does not resolve them except in work dir) and strips .. segments
+    // from paths going beyond root (e.g. `/../../a/b/c` -> `/a/b/c/`). It's simpler also because it
+    // ignores less important corner cases: drive letters are not stripped from absolute paths on
+    // Windows and UNC paths are not handled in a special way (at least on Linux). Finally, it has
+    // very little test coverage so there might be more differences that we are just not aware of.
+    const absoluteSourcePath = path.resolve(sourcePath);
+    for (const absolutePrefix of [absoluteBasePath].concat(absoluteIncludePaths)) {
+        const relativeSourcePath = path.relative(absolutePrefix, absoluteSourcePath);
+        if (!relativeSourcePath.startsWith('../')) {
+            return withUnixPathSeparators(relativeSourcePath);
+        }
+    }
+    // File is not located inside base path or include paths so use its absolute path.
+    return withUnixPathSeparators(absoluteSourcePath);
+}
+function toFormattedJson(input) {
+    return JSON.stringify(input, null, program.prettyJson ? 4 : 0);
+}
+function reformatJsonIfRequested(inputJson) {
+    return (program.prettyJson ? toFormattedJson(JSON.parse(inputJson)) : inputJson);
+}
+let callbacks;
+if (options.basePath || !options.standardJson) {
+    callbacks = { import: readFileCallback };
+}
+if (options.standardJson) {
+    const input = fs.readFileSync(process.stdin.fd).toString('utf8');
+    if (program.verbose) {
+        console.log('>>> 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.');
+        }
+        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');
+                }
+                output = reformatJsonIfRequested(index_1.default.compile(JSON.stringify(inputJSON), callbacks));
+            }
+        }
+    }
+    catch (e) {
+        const addError = {
+            component: 'general',
+            formattedMessage: e.toString(),
+            message: e.toString(),
+            type: 'Warning'
+        };
+        const outputJSON = JSON.parse(output);
+        if (!outputJSON.errors) {
+            outputJSON.errors = [];
+        }
+        outputJSON.errors.push(addError);
+        output = toFormattedJson(outputJSON);
+    }
+    if (program.verbose) {
+        console.log('>>> Compilation result:');
+    }
+    console.log(output);
+    process.exit(0);
+}
+else if (files.length === 0) {
+    console.error('Must provide a file');
+    process.exit(1);
+}
+if (!(options.bin || options.abi)) {
+    abort('Invalid option selected, must specify either --bin or --abi');
+}
+if (!options.basePath && options.includePath && options.includePath.length > 0) {
+    abort('--include-path option requires a non-empty base path.');
+}
+if (options.includePath) {
+    for (const includePath of options.includePath) {
+        if (!includePath) {
+            abort('Empty values are not allowed in --include-path.');
+        }
+    }
+}
+const sources = {};
+for (let i = 0; i < files.length; i++) {
+    try {
+        sources[makeSourcePathRelativeIfPossible(files[i])] = {
+            content: fs.readFileSync(files[i]).toString()
+        };
+    }
+    catch (e) {
+        abort('Error reading ' + files[i] + ': ' + e);
+    }
+}
+const cliInput = {
+    language: 'Hyperion',
+    settings: {
+        optimizer: {
+            enabled: options.optimize,
+            runs: options.optimizeRuns
+        },
+        outputSelection: {
+            '*': {
+                '*': ['abi', 'zvm.bytecode']
+            }
+        }
+    },
+    sources: sources
+};
+if (program.verbose) {
+    console.log('>>> Compiling:\n' + toFormattedJson(cliInput) + '\n');
+}
+const output = JSON.parse(index_1.default.compile(JSON.stringify(cliInput), callbacks));
+let hasError = false;
+if (!output) {
+    abort('No output from compiler');
+}
+else if (output.errors) {
+    for (const error in output.errors) {
+        const message = output.errors[error];
+        if (message.severity === 'warning') {
+            console.log(message.formattedMessage);
+        }
+        else {
+            console.error(message.formattedMessage);
+            hasError = true;
+        }
+    }
+}
+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);
+        }
+    });
+}
+for (const fileName in output.contracts) {
+    for (const contractName in output.contracts[fileName]) {
+        let contractFileName = fileName + ':' + contractName;
+        contractFileName = contractFileName.replace(/[:./\\]/g, '_');
+        if (options.bin) {
+            writeFile(contractFileName + '.bin', output.contracts[fileName][contractName].zvm.bytecode.object);
+        }
+        if (options.abi) {
+            writeFile(contractFileName + '.abi', toFormattedJson(output.contracts[fileName][contractName].abi));
+        }
+    }
+}
+// Put back original exception handlers.
+originalUncaughtExceptionListeners.forEach(function (listener) {
+    process.addListener('uncaughtException', listener);
+});
+if (hasError) {
+    process.exit(1);
+}