@theqrl/hypc 0.0.2

package/test/resources/importCallback/includeB/libZ.hyp

@@ -0,0 +1,4 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma hyperion >=0.0.1;
+
+library Z {}

package/test/resources/smtChecker/loop.hyp

@@ -0,0 +1,8 @@
+contract C {
+	function f(uint x) public pure {
+		uint i = 0;
+		while (i < x)
+			++i;
+		assert(i == x);
+	}
+}

package/test/resources/smtChecker/smoke.hyp

@@ -0,0 +1,5 @@
+pragma experimental SMTChecker;
+contract C {
+	function f() public pure {
+	}
+}

package/test/resources/smtChecker/smoke_with_engine.hyp

@@ -0,0 +1,6 @@
+contract C {
+	function f() public pure {
+	}
+}
+// ====
+// SMTEngine: all

package/test/resources/smtChecker/smoke_with_multi_engine.hyp

@@ -0,0 +1,8 @@
+pragma experimental SMTChecker;
+contract C {
+	function f() public pure {
+	}
+}
+// ====
+// SMTEngine: all
+// SMTEngine: chc

package/test/smtcallback.js

@@ -0,0 +1,221 @@
+"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 assert_1 = __importDefault(require("assert"));
+const tape_1 = __importDefault(require("tape"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const __1 = __importDefault(require("../"));
+const smtchecker_1 = __importDefault(require("../smtchecker"));
+const smtsolver_1 = __importDefault(require("../smtsolver"));
+const preamble = 'pragma hyperion >=0.0.1;\n// SPDX-License-Identifier: GPL-3.0\n';
+function collectErrors(hypOutput) {
+    if (hypOutput === undefined) {
+        return [];
+    }
+    const errors = [];
+    for (const i in hypOutput.errors) {
+        const error = hypOutput.errors[i];
+        if (error.message.includes('This is a pre-release compiler version')) {
+            continue;
+        }
+        errors.push(error.message);
+    }
+    return errors;
+}
+function expectErrors(expectations, errors, ignoreCex) {
+    if (errors.length !== expectations.length) {
+        return false;
+    }
+    for (const i in errors) {
+        if (errors[i].includes('Error trying to invoke SMT solver') || expectations[i].includes('Error trying to invoke SMT solver')) {
+            continue;
+        }
+        // Expectations containing counterexamples might have many '\n' in a single line.
+        // These are stored escaped in the test format (as '\\n'), whereas the actual error from the compiler has '\n'.
+        // Therefore we need to replace '\\n' by '\n' in the expectations.
+        // Function `replace` only replaces the first occurrence, and `replaceAll` is not standard yet.
+        // Replace all '\\n' by '\n' via split & join.
+        expectations[i] = expectations[i].split('\\n').join('\n');
+        if (ignoreCex) {
+            expectations[i] = expectations[i].split('\nCounterexample')[0];
+            errors[i] = errors[i].split('\nCounterexample')[0];
+        }
+        // `expectations` have "// Warning ... " before the actual message,
+        // whereas `errors` have only the message.
+        if (!expectations[i].includes(errors[i])) {
+            return false;
+        }
+    }
+    return true;
+}
+(0, tape_1.default)('SMTCheckerCallback', function (t) {
+    t.test('Interface via callback', function (st) {
+        const satCallback = function (query) {
+            return { contents: 'sat\n' };
+        };
+        const unsatCallback = function (query) {
+            return { contents: 'unsat\n' };
+        };
+        const errorCallback = function (query) {
+            return { error: 'Fake SMT solver error.' };
+        };
+        const settings = { modelChecker: { engine: 'all' } };
+        const input = { a: { content: preamble + 'contract C { function f(uint x) public pure { assert(x > 0); } }' } };
+        const inputJSON = JSON.stringify({
+            language: 'Hyperion',
+            sources: input,
+            settings: settings
+        });
+        const tests = [
+            { cb: satCallback, expectations: ['Assertion violation happens here'] },
+            { cb: unsatCallback, expectations: ['Assertion violation happens here'] },
+            { cb: errorCallback, expectations: ['Assertion violation happens here'] }
+        ];
+        for (const i in tests) {
+            const test = tests[i];
+            const output = JSON.parse(__1.default.compile(inputJSON, { smtSolver: test.cb }));
+            const errors = collectErrors(output);
+            st.ok(expectErrors(errors, test.expectations, false));
+        }
+        st.end();
+    });
+    t.test('Hyperion smtCheckerTests', function (st) {
+        const testdir = path.resolve(__dirname, 'resources/smtChecker/');
+        if (!fs.existsSync(testdir)) {
+            st.skip('SMT checker tests not present.');
+            st.end();
+            return;
+        }
+        // For these tests we actually need z3/Spacer.
+        const z3HornSolvers = smtsolver_1.default.availableSolvers.filter(solver => solver.command === 'z3');
+        if (z3HornSolvers.length === 0) {
+            st.skip('z3/Spacer not available.');
+            st.end();
+            return;
+        }
+        const sources = [];
+        // BFS to get all test files
+        const dirs = [testdir];
+        let i;
+        while (dirs.length > 0) {
+            const dir = dirs.shift();
+            const files = fs.readdirSync(dir);
+            for (i in files) {
+                const file = path.join(dir, files[i]);
+                if (fs.statSync(file).isDirectory()) {
+                    dirs.push(file);
+                }
+                else {
+                    sources.push(file);
+                }
+            }
+        }
+        // Read tests and collect expectations
+        const tests = [];
+        for (i in sources) {
+            st.comment('Collecting ' + sources[i] + '...');
+            const source = fs.readFileSync(sources[i], 'utf8');
+            let engine;
+            const option = '// SMTEngine: ';
+            if (source.includes(option)) {
+                const idx = source.indexOf(option);
+                if (source.indexOf(option, idx + 1) !== -1) {
+                    st.comment('SMTEngine option given multiple times.');
+                    continue;
+                }
+                const re = new RegExp(option + '(\\w+)');
+                const m = source.match(re);
+                (0, assert_1.default)(m !== undefined);
+                (0, assert_1.default)(m.length >= 2);
+                engine = m[1];
+            }
+            let expected = [];
+            const delimiter = '// ----';
+            if (source.includes(delimiter)) {
+                expected = source.substring(source.indexOf('// ----') + 8, source.length).split('\n');
+                // Sometimes the last expectation line ends with a '\n'
+                if (expected.length > 0 && expected[expected.length - 1] === '') {
+                    expected.pop();
+                }
+            }
+            tests[sources[i]] = {
+                expectations: expected,
+                hyperion: { test: { content: preamble + source } },
+                ignoreCex: source.includes('// SMTIgnoreCex: yes'),
+                engine: engine
+            };
+        }
+        // Run all tests
+        for (i in tests) {
+            const test = tests[i];
+            // Z3's nondeterminism sometimes causes a test to timeout in one context but not in the other,
+            // so if we see timeout we skip a potentially misleading run.
+            const findError = (errorMsg) => { return errorMsg.includes('Error trying to invoke SMT solver'); };
+            if (test.expectations.find(findError) !== undefined) {
+                st.skip('Test contains timeout which may have been caused by nondeterminism.');
+                continue;
+            }
+            let settings = {};
+            const engine = test.engine !== undefined ? test.engine : 'all';
+            settings = {
+                modelChecker: {
+                    engine: engine,
+                    solvers: [
+                        'smtlib2'
+                    ]
+                }
+            };
+            const output = JSON.parse(__1.default.compile(JSON.stringify({
+                language: 'Hyperion',
+                sources: test.hyperion,
+                settings: settings
+            }), 
+            // This test needs z3 specifically.
+            { smtSolver: smtchecker_1.default.smtCallback(smtsolver_1.default.smtSolver, z3HornSolvers[0]) }));
+            st.ok(output);
+            // Collect obtained error messages
+            test.errors = collectErrors(output);
+            // These are errors in the SMTLib2Interface encoding.
+            if (test.errors.length > 0 && test.errors[test.errors.length - 1].includes('BMC analysis was not possible')) {
+                continue;
+            }
+            // These are due to CHC not being supported via SMTLib2Interface yet.
+            if (test.expectations.length !== test.errors.length) {
+                continue;
+            }
+            if (test.errors.find(findError) !== undefined) {
+                st.skip('Test contains timeout which may have been caused by nondeterminism.');
+                continue;
+            }
+            // Compare expected vs obtained errors
+            st.ok(expectErrors(test.expectations, test.errors, test.ignoreCex));
+        }
+        st.end();
+    });
+});

package/test/smtchecker.js

@@ -0,0 +1,83 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const tape_1 = __importDefault(require("tape"));
+const __1 = __importDefault(require("../"));
+const smtchecker_1 = __importDefault(require("../smtchecker"));
+const smtsolver_1 = __importDefault(require("../smtsolver"));
+const preamble = 'pragma hyperion >=0.0.1;\n// SPDX-License-Identifier: GPL-3.0\n';
+//
+(0, tape_1.default)('SMTChecker', function (t) {
+    // We use null for `solverFunction` and `solver` when calling `handleSMTQueries`
+    // because these tests do not call a solver.
+    t.test('smoke test with no axuiliaryInputRequested', function (st) {
+        const input = {};
+        const output = {};
+        st.equal(smtchecker_1.default.handleSMTQueries(input, output, null, null), null);
+        st.end();
+    });
+    t.test('smoke test with no smtlib2queries', function (st) {
+        const input = {};
+        const output = { auxiliaryInputRequested: {} };
+        st.equal(smtchecker_1.default.handleSMTQueries(input, output, null, null), null);
+        st.end();
+    });
+    t.test('smoke test with empty smtlib2queries', function (st) {
+        const input = {};
+        const output = { auxiliaryInputRequested: { smtlib2queries: {} } };
+        st.equal(smtchecker_1.default.handleSMTQueries(input, output, null, null), null);
+        st.end();
+    });
+    t.test('smtCallback should return type function', (st) => {
+        const response = smtchecker_1.default.smtCallback(() => { });
+        st.equal(typeof response, 'function');
+        st.end();
+    });
+    t.test('smtCallback should error when passed parser fails', (st) => {
+        const cbFun = smtchecker_1.default.smtCallback((content) => { throw new Error(content); });
+        const response = cbFun('expected-error-message');
+        st.deepEqual(response, { error: new Error('expected-error-message') });
+        st.end();
+    });
+    t.test('smtCallback should return content when passed parser does not fail', (st) => {
+        const cbFun = smtchecker_1.default.smtCallback((content) => { return content; });
+        const response = cbFun('expected-content-message');
+        st.deepEqual(response, { contents: 'expected-content-message' });
+        st.end();
+    });
+});
+(0, tape_1.default)('SMTCheckerWithSolver', function (t) {
+    // In these tests we require z3 to actually run the solver.
+    // This uses the SMT double run mechanism instead of the callback.
+    t.test('Simple test with axuiliaryInputRequested', function (st) {
+        const z3 = smtsolver_1.default.availableSolvers.filter(solver => solver.command === 'z3');
+        if (z3.length === 0) {
+            st.skip('Test requires z3.');
+            st.end();
+            return;
+        }
+        const settings = {
+            modelChecker: {
+                engine: 'chc',
+                solvers: ['smtlib2']
+            }
+        };
+        const source = { a: { content: preamble + '\ncontract C { function f(uint x) public pure { assert(x > 0); } }' } };
+        const input = {
+            language: 'Hyperion',
+            sources: source,
+            settings: settings
+        };
+        const output = JSON.parse(__1.default.compile(JSON.stringify(input)));
+        st.ok(output);
+        const newInput = smtchecker_1.default.handleSMTQueries(input, output, smtsolver_1.default.smtSolver, z3[0]);
+        st.notEqual(newInput, null);
+        const newOutput = JSON.parse(__1.default.compile(JSON.stringify(newInput)));
+        st.ok(newOutput);
+        const smtErrors = newOutput.errors.filter(e => e.errorCode === '6328');
+        st.equal(smtErrors.length, 1);
+        st.end();
+    });
+});

package/test/translate.js

@@ -0,0 +1,83 @@
+"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 fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const tape_1 = __importDefault(require("tape"));
+const translate_1 = __importDefault(require("../translate"));
+const versionToSemver = translate_1.default.versionToSemver;
+(0, tape_1.default)('Version string to Semver translator', function (t) {
+    t.test('Only numbers', function (st) {
+        st.equal(versionToSemver('0.1.0'), '0.1.0');
+        st.end();
+    });
+    t.test('New style release (semver)', function (st) {
+        st.equal(versionToSemver('0.4.5+commit.b318366e.Emscripten.clang'), '0.4.5+commit.b318366e.Emscripten.clang');
+        st.end();
+    });
+    t.test('New style nightly (semver)', function (st) {
+        st.equal(versionToSemver('0.4.20-nightly.2018.2.13+commit.27ef9794.Emscripten.clang'), '0.4.20-nightly.2018.2.13+commit.27ef9794.Emscripten.clang');
+        st.end();
+    });
+    t.test('Old style 0.1.1', function (st) {
+        st.equal(versionToSemver('0.1.1-6ff4cd6b/RelWithDebInfo-Emscripten/clang/int'), '0.1.1+commit.6ff4cd6b');
+        st.end();
+    });
+    t.test('Old style 0.1.2', function (st) {
+        st.equal(versionToSemver('0.1.2-5c3bfd4b*/.-/clang/int'), '0.1.2+commit.5c3bfd4b');
+        st.end();
+    });
+    t.test('Broken 0.1.3', function (st) {
+        st.equal(versionToSemver('0.1.3-0/.-/clang/int linked to libzond-0.9.92-0/.-/clang/int'), '0.1.3');
+        st.end();
+    });
+    t.test('Old style 0.2.0', function (st) {
+        st.equal(versionToSemver('0.2.0-e7098958/.-Emscripten/clang/int linked to libzond-1.1.1-bbb80ab0/.-Emscripten/clang/int'), '0.2.0+commit.e7098958');
+        st.end();
+    });
+    t.test('Old style 0.3.5', function (st) {
+        // The one in the hypc-bin list
+        st.equal(versionToSemver('0.3.5-371690f0/Release-Emscripten/clang/Interpreter'), '0.3.5+commit.371690f0');
+        // The actual one reported by the compiler
+        st.equal(versionToSemver('0.3.5-0/Release-Emscripten/clang/Interpreter'), '0.3.5');
+        st.end();
+    });
+    t.test('Old style 0.3.6', function (st) {
+        st.equal(versionToSemver('0.3.6-3fc68da5/Release-Emscripten/clang'), '0.3.6+commit.3fc68da5');
+        st.end();
+    });
+});
+(0, tape_1.default)('prettyPrintLegacyAssemblyJSON', function (t) {
+    t.test('Works properly', function (st) {
+        const fixtureAsmJson = JSON.parse(fs.readFileSync(path.resolve(__dirname, 'resources/fixtureAsmJson.json')).toString());
+        const fixtureAsmJsonSource = fs.readFileSync(path.resolve(__dirname, 'resources/fixtureAsmJson.hyp')).toString();
+        const fixtureAsmJsonOutput = fs.readFileSync(path.resolve(__dirname, 'resources/fixtureAsmJson.output')).toString();
+        st.equal(translate_1.default.prettyPrintLegacyAssemblyJSON(fixtureAsmJson, fixtureAsmJsonSource), fixtureAsmJsonOutput);
+        st.end();
+    });
+});

package/test_resources_fixtureSmoke_hyp_C.abi

@@ -0,0 +1 @@
+[{"inputs":[],"name":"f","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"}]

package/test_resources_fixtureSmoke_hyp_C.bin

@@ -0,0 +1 @@
+6080604052348015600e575f80fd5b5060ab8061001b5f395ff3fe6080604052348015600e575f80fd5b50600436106026575f3560e01c806326121ff014602a575b5f80fd5b60306044565b604051603b9190605e565b60405180910390f35b5f90565b5f819050919050565b6058816048565b82525050565b5f602082019050606f5f8301846051565b9291505056fea2646970667358221220a64bffebed1b5ea46c9e55283bb4753bda96a1f1cc64c005260afedb8a70c40a6468797063430000020033

package/test_resources_importA_hyp_C.bin

@@ -0,0 +1 @@
+6080604052348015600e575f80fd5b5060ab8061001b5f395ff3fe6080604052348015600e575f80fd5b50600436106026575f3560e01c806326121ff014602a575b5f80fd5b60306044565b604051603b9190605e565b60405180910390f35b5f90565b5f819050919050565b6058816048565b82525050565b5f602082019050606f5f8301846051565b9291505056fea26469706673582212203cd9e1982d54d4d890bf8e70885702652542c82b6abb83e7c15acee85073406c6468797063430000020033

package/test_resources_importB_hyp_D.bin

@@ -0,0 +1 @@
+6080604052348015600e575f80fd5b5060ab8061001b5f395ff3fe6080604052348015600e575f80fd5b50600436106026575f3560e01c806326121ff014602a575b5f80fd5b60306044565b604051603b9190605e565b60405180910390f35b5f90565b5f819050919050565b6058816048565b82525050565b5f602082019050606f5f8301846051565b9291505056fea26469706673582212207037e01e24ae6d283b7725b9545b7c4376d40d1a1186404fcfd6d3b064b2ca786468797063430000020033

package/translate.js

@@ -0,0 +1,186 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const linker_1 = __importDefault(require("./linker"));
+/// Translate old style version numbers to semver.
+/// Old style: 0.3.6-3fc68da5/Release-Emscripten/clang
+///            0.3.5-371690f0/Release-Emscripten/clang/Interpreter
+///            0.3.5-0/Release-Emscripten/clang/Interpreter
+///            0.2.0-e7098958/.-Emscripten/clang/int linked to libzond-1.1.1-bbb80ab0/.-Emscripten/clang/int
+///            0.1.3-0/.-/clang/int linked to libzond-0.9.92-0/.-/clang/int
+///            0.1.2-5c3bfd4b*/.-/clang/int
+///            0.1.1-6ff4cd6b/RelWithDebInfo-Emscripten/clang/int
+/// New style: 0.4.5+commit.b318366e.Emscripten.clang
+function versionToSemver(version) {
+    // FIXME: parse more detail, but this is a good start
+    const parsed = version.match(/^([0-9]+\.[0-9]+\.[0-9]+)-([0-9a-f]{8})[/*].*$/);
+    if (parsed) {
+        return parsed[1] + '+commit.' + parsed[2];
+    }
+    if (version.indexOf('0.1.3-0') !== -1) {
+        return '0.1.3';
+    }
+    if (version.indexOf('0.3.5-0') !== -1) {
+        return '0.3.5';
+    }
+    // assume it is already semver compatible
+    return version;
+}
+function translateErrors(ret, errors) {
+    for (const error in errors) {
+        let type = 'error';
+        let extractType = /^(.*):(\d+):(\d+):(.*):/;
+        extractType = extractType.exec(errors[error]);
+        if (extractType) {
+            type = extractType[4].trim();
+        }
+        else if (errors[error].indexOf(': Warning:')) {
+            type = 'Warning';
+        }
+        else if (errors[error].indexOf(': Error:')) {
+            type = 'Error';
+        }
+        ret.push({
+            type: type,
+            component: 'general',
+            severity: (type === 'Warning') ? 'warning' : 'error',
+            message: errors[error],
+            formattedMessage: errors[error]
+        });
+    }
+}
+function translateGasEstimates(gasEstimates) {
+    if (gasEstimates === null) {
+        return 'infinite';
+    }
+    if (typeof gasEstimates === 'number') {
+        return gasEstimates.toString();
+    }
+    const gasEstimatesTranslated = {};
+    for (const func in gasEstimates) {
+        gasEstimatesTranslated[func] = translateGasEstimates(gasEstimates[func]);
+    }
+    return gasEstimatesTranslated;
+}
+function translateJsonCompilerOutput(output, libraries) {
+    const ret = {};
+    ret.errors = [];
+    let errors;
+    if (output.error) {
+        errors = [output.error];
+    }
+    else {
+        errors = output.errors;
+    }
+    translateErrors(ret.errors, errors);
+    ret.contracts = {};
+    for (const contract in output.contracts) {
+        // Split name first, can be `contract`, `:contract` or `filename:contract`
+        const tmp = contract.match(/^((.*):)?([^:]+)$/);
+        if (tmp.length !== 4) {
+            // Force abort
+            return null;
+        }
+        let fileName = tmp[2];
+        if (fileName === undefined) {
+            // this is the case of `contract`
+            fileName = '';
+        }
+        const contractName = tmp[3];
+        const contractInput = output.contracts[contract];
+        const gasEstimates = contractInput.gasEstimates;
+        const translatedGasEstimates = {};
+        if (gasEstimates.creation) {
+            translatedGasEstimates.creation = {
+                codeDepositCost: translateGasEstimates(gasEstimates.creation[1]),
+                executionCost: translateGasEstimates(gasEstimates.creation[0])
+            };
+        }
+        if (gasEstimates.internal) {
+            translatedGasEstimates.internal = translateGasEstimates(gasEstimates.internal);
+        }
+        if (gasEstimates.external) {
+            translatedGasEstimates.external = translateGasEstimates(gasEstimates.external);
+        }
+        const contractOutput = {
+            abi: JSON.parse(contractInput.interface),
+            metadata: contractInput.metadata,
+            zvm: {
+                legacyAssembly: contractInput.assembly,
+                bytecode: {
+                    object: contractInput.bytecode && linker_1.default.linkBytecode(contractInput.bytecode, libraries || {}),
+                    opcodes: contractInput.opcodes,
+                    sourceMap: contractInput.srcmap,
+                    linkReferences: contractInput.bytecode && linker_1.default.findLinkReferences(contractInput.bytecode)
+                },
+                deployedBytecode: {
+                    object: contractInput.runtimeBytecode && linker_1.default.linkBytecode(contractInput.runtimeBytecode, libraries || {}),
+                    sourceMap: contractInput.srcmapRuntime,
+                    linkReferences: contractInput.runtimeBytecode && linker_1.default.findLinkReferences(contractInput.runtimeBytecode)
+                },
+                methodIdentifiers: contractInput.functionHashes,
+                gasEstimates: translatedGasEstimates
+            }
+        };
+        if (!ret.contracts[fileName]) {
+            ret.contracts[fileName] = {};
+        }
+        ret.contracts[fileName][contractName] = contractOutput;
+    }
+    const sourceMap = {};
+    for (const sourceId in output.sourceList) {
+        sourceMap[output.sourceList[sourceId]] = sourceId;
+    }
+    ret.sources = {};
+    for (const source in output.sources) {
+        ret.sources[source] = {
+            id: sourceMap[source],
+            legacyAST: output.sources[source].AST
+        };
+    }
+    return ret;
+}
+function escapeString(text) {
+    return text
+        .replace(/\n/g, '\\n')
+        .replace(/\r/g, '\\r')
+        .replace(/\t/g, '\\t');
+}
+// 'asm' can be an object or a string
+function formatAssemblyText(asm, prefix, source) {
+    if (typeof asm === 'string' || asm === null || asm === undefined) {
+        return prefix + (asm || '') + '\n';
+    }
+    let text = prefix + '.code\n';
+    asm['.code'].forEach(function (item, i) {
+        const v = item.value === undefined ? '' : item.value;
+        let src = '';
+        if (source !== undefined && item.begin !== undefined && item.end !== undefined) {
+            src = escapeString(source.slice(item.begin, item.end));
+        }
+        if (src.length > 30) {
+            src = src.slice(0, 30) + '...';
+        }
+        if (item.name !== 'tag') {
+            text += '  ';
+        }
+        text += prefix + item.name + ' ' + v + '\t\t\t' + src + '\n';
+    });
+    text += prefix + '.data\n';
+    const asmData = asm['.data'] || [];
+    for (const i in asmData) {
+        const item = asmData[i];
+        text += '  ' + prefix + '' + i + ':\n';
+        text += formatAssemblyText(item, prefix + '    ', source);
+    }
+    return text;
+}
+function prettyPrintLegacyAssemblyJSON(assembly, source) {
+    return formatAssemblyText(assembly, '', source);
+}
+module.exports = {
+    versionToSemver,
+    translateJsonCompilerOutput,
+    prettyPrintLegacyAssemblyJSON
+};

package/tsconfig.json

@@ -0,0 +1,25 @@
+{
+    "compilerOptions": {
+        "target": "esnext",
+        "module": "commonjs",
+        "resolveJsonModule": true,
+        "esModuleInterop": true,
+        "outDir": "./dist",
+        "forceConsistentCasingInFileNames": true,
+        "allowJs": true,
+        "strict": false,
+        "noImplicitAny": false
+    },
+    "include": [
+        "**/*.js",
+        "**/*.ts",
+        "**/*.json"
+    ],
+    "exclude": [
+        "coverage",
+        "dist"
+    ],
+    "ts-node": {
+        "transpileOnly": true
+    }
+}

package/utils_hyp_Utils.bin

@@ -0,0 +1 @@
+6055604b600b8282823980515f1a607314603f577f4e487b71000000000000000000000000000000000000000000000000000000005f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f80fdfea2646970667358221220c6f7f973579a348b89e77c0e22d1800927ba997a07148e7c7b4d9cff3451b45c6468797063430000020033