@theqrl/hypc 0.0.2

package/importA_hyp_C.bin

@@ -0,0 +1 @@
+6080604052348015600e575f80fd5b5060ab8061001b5f395ff3fe6080604052348015600e575f80fd5b50600436106026575f3560e01c806326121ff014602a575b5f80fd5b60306044565b604051603b9190605e565b60405180910390f35b5f90565b5f819050919050565b6058816048565b82525050565b5f602082019050606f5f8301846051565b9291505056fea264697066735822122003aa2795a073c7ca2063308c3a8a13fb3a1ce6028c399f889636bd9eabe1f73f6468797063430000020033

package/importB_hyp_D.bin

@@ -0,0 +1 @@
+6080604052348015600e575f80fd5b5060ab8061001b5f395ff3fe6080604052348015600e575f80fd5b50600436106026575f3560e01c806326121ff014602a575b5f80fd5b60306044565b604051603b9190605e565b60405180910390f35b5f90565b5f819050919050565b6058816048565b82525050565b5f602082019050606f5f8301846051565b9291505056fea2646970667358221220f96d6c685f4fe201ee93ca17a8b69d8182984a86c16908f46d7becc54efcfb846468797063430000020033

package/index.js

@@ -0,0 +1,7 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const wrapper_1 = __importDefault(require("./wrapper"));
+const hypjson = require('./hypjson.js');
+module.exports = (0, wrapper_1.default)(hypjson);

package/libX_hyp_X.bin

@@ -0,0 +1 @@
+6055604b600b8282823980515f1a607314603f577f4e487b71000000000000000000000000000000000000000000000000000000005f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f80fdfea2646970667358221220e78306f3d7dc80c45acbd51f639ead3e6f620f10144ea624b2c7e88c6c1504e96468797063430000020033

package/libY_hyp_Y.bin

@@ -0,0 +1 @@
+6055604b600b8282823980515f1a607314603f577f4e487b71000000000000000000000000000000000000000000000000000000005f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f80fdfea2646970667358221220fe2cbe5e62e395650d519ac764d3d5271e9af30d3e271d1c291677812e14d7ce6468797063430000020033

package/libZ_hyp_Z.bin

@@ -0,0 +1 @@
+6055604b600b8282823980515f1a607314603f577f4e487b71000000000000000000000000000000000000000000000000000000005f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f80fdfea26469706673582212208cf9773d6268fc017aed7c3282d7e4ec482fd3b5d956250412103e5d65854bfc6468797063430000020033

package/linker.js

@@ -0,0 +1,156 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const assert_1 = __importDefault(require("assert"));
+const js_sha3_1 = require("js-sha3");
+const helpers_1 = require("./common/helpers");
+/**
+ * Generates a new-style library placeholder from a fully-qualified library name.
+ *
+ * Newer versions of the compiler use hashed names instead of just truncating the name
+ * before putting it in a placeholder.
+ *
+ * @param fullyQualifiedLibraryName Fully qualified library name.
+ */
+function libraryHashPlaceholder(fullyQualifiedLibraryName) {
+    return `$${(0, js_sha3_1.keccak256)(fullyQualifiedLibraryName).slice(0, 34)}$`;
+}
+/**
+ * Finds all placeholders corresponding to the specified library label and replaces them
+ * with a concrete address. Works with both hex-encoded and binary bytecode as long as
+ * the address is in the same format.
+ *
+ * @param bytecode Bytecode string.
+ *
+ * @param label Library label, either old- or new-style. Must exactly match the part between `__` markers in the
+ *     placeholders. Will be padded with `_` characters if too short or truncated if too long.
+ *
+ * @param address Address to replace placeholders with. Must be the right length.
+ *     It will **not** be padded with zeros if too short.
+ */
+function replacePlaceholder(bytecode, label, address) {
+    // truncate to 36 characters
+    const truncatedName = label.slice(0, 36);
+    const libLabel = `__${truncatedName.padEnd(36, '_')}__`;
+    while (bytecode.indexOf(libLabel) >= 0) {
+        bytecode = bytecode.replace(libLabel, address);
+    }
+    return bytecode;
+}
+/**
+ * Finds and all library placeholders in the provided bytecode and replaces them with actual addresses.
+ * Supports both old- and new-style placeholders (even both in the same file).
+ * See [Library Linking](https://docs.soliditylang.org/en/latest/using-the-compiler.html#library-linking)
+ * for a full explanation of the linking process.
+ *
+ * Example of a legacy placeholder: `__lib.hyp:L_____________________________`
+ * Example of a new-style placeholder: `__$7484607a72fb0587588e5a1e608f0b16de$__`
+ *
+ * @param bytecode Hex-encoded bytecode string. All 40-byte substrings starting and ending with
+ *     `__` will be interpreted as placeholders.
+ *
+ * @param libraries Mapping between fully qualified library names and the hex-encoded
+ *     addresses they should be replaced with. Addresses shorter than 40 characters are automatically padded with zeros.
+ *
+ * @returns bytecode Hex-encoded bytecode string with placeholders replaced with addresses.
+ *    Note that some placeholders may remain in the bytecode if `libraries` does not provide addresses for all of them.
+ */
+function linkBytecode(bytecode, libraries) {
+    (0, assert_1.default)(typeof bytecode === 'string');
+    (0, assert_1.default)(typeof libraries === 'object');
+    // NOTE: for backwards compatibility support old compiler which didn't use file names
+    const librariesComplete = {};
+    for (const [fullyQualifiedLibraryName, libraryObjectOrAddress] of Object.entries(libraries)) {
+        if ((0, helpers_1.isNil)(libraryObjectOrAddress)) {
+            throw new Error(`No address provided for library ${fullyQualifiedLibraryName}`);
+        }
+        // API compatible with the standard JSON i/o
+        // {"lib.hyp": {"L": "Z..."}}
+        if ((0, helpers_1.isObject)(libraryObjectOrAddress)) {
+            for (const [unqualifiedLibraryName, address] of Object.entries(libraryObjectOrAddress)) {
+                librariesComplete[unqualifiedLibraryName] = address;
+                librariesComplete[`${fullyQualifiedLibraryName}:${unqualifiedLibraryName}`] = address;
+            }
+            continue;
+        }
+        // backwards compatible API for early hypc-js versions
+        const parsed = fullyQualifiedLibraryName.match(/^(?<sourceUnitName>[^:]+):(?<unqualifiedLibraryName>.+)$/);
+        const libraryAddress = libraryObjectOrAddress;
+        if (!(0, helpers_1.isNil)(parsed)) {
+            const { unqualifiedLibraryName } = parsed.groups;
+            librariesComplete[unqualifiedLibraryName] = libraryAddress;
+        }
+        librariesComplete[fullyQualifiedLibraryName] = libraryAddress;
+    }
+    for (const libraryName in librariesComplete) {
+        let hexAddress = librariesComplete[libraryName];
+        if (!hexAddress.startsWith('Z') || hexAddress.length > 41) {
+            throw new Error(`Invalid address specified for ${libraryName}`);
+        }
+        // remove 0x prefix
+        hexAddress = hexAddress.slice(1).padStart(40, '0');
+        bytecode = replacePlaceholder(bytecode, libraryName, hexAddress);
+        bytecode = replacePlaceholder(bytecode, libraryHashPlaceholder(libraryName), hexAddress);
+    }
+    return bytecode;
+}
+/**
+ * Finds locations of all library address placeholders in the hex-encoded bytecode.
+ * Returns information in a format matching `zvm.bytecode.linkReferences` output
+ * in Standard JSON.
+ *
+ * See [Library Linking](https://docs.soliditylang.org/en/latest/using-the-compiler.html#library-linking)
+ * for a full explanation of library placeholders and linking process.
+ *
+ * WARNING: The output matches `zvm.bytecode.linkReferences` exactly only in
+ * case of old-style placeholders created from fully qualified library names
+ * of no more than 36 characters, and even then only if the name does not start
+ * or end with an underscore. This is different from
+ * `zvm.bytecode.linkReferences`, which uses fully qualified library names.
+ * This is a limitation of the placeholder format - the fully qualified names
+ * are not preserved in the compiled bytecode and cannot be reconstructed
+ * without external information.
+ *
+ * @param bytecode Hex-encoded bytecode string.
+ *
+ * @returns linkReferences A mapping between library labels and their locations
+ * in the bytecode. In case of old-style placeholders the label is a fully
+ * qualified library name truncated to 36 characters. For new-style placeholders
+ * it's the first 34 characters of the hex-encoded hash of the fully qualified
+ * library name, with a leading and trailing $ character added. Note that the
+ * offsets and lengths refer to the *binary* (not hex-encoded) bytecode, just
+ * like in `zvm.bytecode.linkReferences`.
+ */
+function findLinkReferences(bytecode) {
+    (0, assert_1.default)(typeof bytecode === 'string');
+    // find 40 bytes in the pattern of __...<36 digits>...__
+    // e.g. __Lib.hyp:L_____________________________
+    const linkReferences = {};
+    let offset = 0;
+    while (true) {
+        const found = bytecode.match(/__(.{36})__/);
+        if (!found) {
+            break;
+        }
+        const start = found.index;
+        // trim trailing underscores
+        // NOTE: this has no way of knowing if the trailing underscore was part of the name
+        const libraryName = found[1].replace(/_+$/gm, '');
+        if (!linkReferences[libraryName]) {
+            linkReferences[libraryName] = [];
+        }
+        // offsets are in bytes in binary representation (and not hex)
+        linkReferences[libraryName].push({
+            start: (offset + start) / 2,
+            length: 20
+        });
+        offset += start + 20;
+        bytecode = bytecode.slice(start + 20);
+    }
+    return linkReferences;
+}
+module.exports = {
+    linkBytecode,
+    findLinkReferences
+};

package/package.json

@@ -0,0 +1,74 @@
+{
+    "name": "@theqrl/hypc",
+    "version": "0.0.2",
+    "description": "Hyperion compiler",
+    "main": "index.js",
+    "bin": {
+        "hypcjs": "hypc.js"
+    },
+    "scripts": {
+        "build": "tsc",
+        "postbuild": "node build/postbuild.js && cp README.md LICENSE dist/",
+        "lint": "eslint --ext .js,.ts .",
+        "lint:fix": "eslint --fix --ext .js,.ts .",
+        "updateBinary": "node build/clean.js && ts-node ./downloadCurrentVersion.ts && ts-node ./verifyVersion.ts",
+        "prepack": "node build/pack-publish-block.js",
+        "build:tarball": "npm run updateBinary && npm run build && BYPASS_SAFETY_CHECK=true npm pack ./dist",
+        "publish:tarball": "tarball=$(npm run --silent tarballName) && ls \"$tarball\" && BYPASS_SAFETY_CHECK=true npm publish --access public \"$tarball\"",
+        "tarballName": "jq --raw-output '.name + \"-\" + .version + \".tgz\"' package.json",
+        "copyTestFiles": "cp -r ./test/resources ./dist/test/",
+        "pretest": "npm run lint && npm run build && npm run copyTestFiles",
+        "test": "cd dist && tape ./test/index.js",
+        "coverage": "nyc npm run test",
+        "coveralls": "npm run coverage && coveralls <coverage/lcov.info"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/theQRL/hypc-js.git"
+    },
+    "keywords": [
+        "zond",
+        "hyperion",
+        "compiler"
+    ],
+    "author": "",
+    "license": "MIT",
+    "bugs": {
+        "url": "https://github.com/theQRL/hypc-js/issues"
+    },
+    "homepage": "https://github.com/theQRL/hypc-js#readme",
+    "dependencies": {
+        "command-exists": "^1.2.8",
+        "commander": "^8.1.0",
+        "follow-redirects": "^1.12.1",
+        "js-sha3": "0.8.0",
+        "memorystream": "^0.3.1",
+        "semver": "^5.5.0",
+        "tmp": "0.0.33"
+    },
+    "devDependencies": {
+        "@types/node": "^16.11.7",
+        "@types/semver": "^7.3.9",
+        "@types/tape": "^4.13.2",
+        "@types/tmp": "^0.2.3",
+        "@typescript-eslint/eslint-plugin": "^5.8.0",
+        "@typescript-eslint/parser": "^5.8.0",
+        "coveralls": "^3.0.0",
+        "eslint": "^7.32.0",
+        "eslint-config-standard": "^16.0.3",
+        "eslint-plugin-import": "^2.25.3",
+        "eslint-plugin-node": "^11.1.0",
+        "eslint-plugin-promise": "^5.1.1",
+        "nyc": "^15.1.0",
+        "tape": "^4.11.0",
+        "tape-spawn": "^1.4.2",
+        "ts-node": "^10.4.0",
+        "typescript": "^4.5.4"
+    },
+    "nyc": {
+        "exclude": [
+            "hypjson.js",
+            "dist"
+        ]
+    }
+}

package/smtchecker.js

@@ -0,0 +1,39 @@
+"use strict";
+// This function checks the standard JSON output for auxiliaryInputRequested,
+// where smtlib2queries represent the queries created by the SMTChecker.
+// The function runs an SMT solver on each query and adjusts the input for
+// another run.
+// Returns null if no solving is requested.
+function handleSMTQueries(inputJSON, outputJSON, solverFunction, solver) {
+    const auxInputReq = outputJSON.auxiliaryInputRequested;
+    if (!auxInputReq) {
+        return null;
+    }
+    const queries = auxInputReq.smtlib2queries;
+    if (!queries || Object.keys(queries).length === 0) {
+        return null;
+    }
+    const responses = {};
+    for (const query in queries) {
+        responses[query] = solverFunction(queries[query], solver);
+    }
+    // Note: all existing solved queries are replaced.
+    // This assumes that all necessary queries are quested above.
+    inputJSON.auxiliaryInput = { smtlib2responses: responses };
+    return inputJSON;
+}
+function smtCallback(solverFunction, solver) {
+    return function (query) {
+        try {
+            const result = solverFunction(query, solver);
+            return { contents: result };
+        }
+        catch (err) {
+            return { error: err };
+        }
+    };
+}
+module.exports = {
+    handleSMTQueries,
+    smtCallback
+};

package/smtsolver.js

@@ -0,0 +1,89 @@
+"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;
+};
+const command_exists_1 = require("command-exists");
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const tmp = __importStar(require("tmp"));
+// Timeout in ms.
+const timeout = 10000;
+const potentialSolvers = [
+    {
+        name: 'z3',
+        command: 'z3',
+        params: '-smt2 rlimit=20000000 rewriter.pull_cheap_ite=true fp.spacer.q3.use_qgen=true fp.spacer.mbqi=false fp.spacer.ground_pobs=false'
+    },
+    {
+        name: 'Eldarica',
+        command: 'eld',
+        params: '-horn -t:' + (timeout / 1000) // Eldarica takes timeout in seconds.
+    },
+    {
+        name: 'cvc4',
+        command: 'cvc4',
+        params: '--lang=smt2 --tlimit=' + timeout
+    }
+];
+const solvers = potentialSolvers.filter(solver => (0, command_exists_1.sync)(solver.command));
+function solve(query, solver) {
+    if (solver === undefined) {
+        if (solvers.length === 0) {
+            throw new Error('No SMT solver available. Assertion checking will not be performed.');
+        }
+        else {
+            solver = solvers[0];
+        }
+    }
+    const tmpFile = tmp.fileSync({ postfix: '.smt2' });
+    fs.writeFileSync(tmpFile.name, query);
+    let solverOutput;
+    try {
+        solverOutput = (0, child_process_1.execSync)(solver.command + ' ' + solver.params + ' ' + tmpFile.name, {
+            encoding: 'utf8',
+            maxBuffer: 1024 * 1024 * 1024,
+            stdio: 'pipe',
+            timeout: timeout // Enforce timeout on the process, since solvers can sometimes go around it.
+        }).toString();
+    }
+    catch (e) {
+        // execSync throws if the process times out or returns != 0.
+        // The latter might happen with z3 if the query asks for a model
+        // for an UNSAT formula. We can still use stdout.
+        solverOutput = e.stdout.toString();
+        if (!solverOutput.startsWith('sat') &&
+            !solverOutput.startsWith('unsat') &&
+            !solverOutput.startsWith('unknown') &&
+            !solverOutput.startsWith('(error') && // Eldarica reports errors in an sexpr, for example: '(error "Failed to reconstruct array model")'
+            !solverOutput.startsWith('error')) {
+            throw new Error('Failed to solve SMT query. ' + e.toString());
+        }
+    }
+    // Trigger early manual cleanup
+    tmpFile.removeCallback();
+    return solverOutput;
+}
+module.exports = {
+    smtSolver: solve,
+    availableSolvers: solvers
+};

package/test/abi.js

@@ -0,0 +1,77 @@
+"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 abi_1 = __importDefault(require("../abi"));
+(0, tape_1.default)('ABI translator', function (t) {
+    t.test('Empty ABI', function (st) {
+        st.deepEqual(abi_1.default.update('0.4.0', []), []);
+        st.end();
+    });
+    t.test('0.1.1 (no constructor)', function (st) {
+        st.deepEqual(abi_1.default.update('0.1.1', []), [{ inputs: [], payable: true, stateMutability: 'payable', type: 'constructor' }, { payable: true, stateMutability: 'payable', type: 'fallback' }]);
+        st.end();
+    });
+    t.test('0.3.6 (constructor)', function (st) {
+        const input = [{ inputs: [], type: 'constructor' }];
+        st.deepEqual(abi_1.default.update('0.3.6', input), [{ inputs: [], payable: true, stateMutability: 'payable', type: 'constructor' }, { payable: true, stateMutability: 'payable', type: 'fallback' }]);
+        st.end();
+    });
+    t.test('0.3.6 (non-constant function)', function (st) {
+        const input = [{ inputs: [], type: 'function' }];
+        st.deepEqual(abi_1.default.update('0.3.6', input), [{ inputs: [], payable: true, stateMutability: 'payable', type: 'function' }, { payable: true, stateMutability: 'payable', type: 'fallback' }]);
+        st.end();
+    });
+    t.test('0.3.6 (constant function)', function (st) {
+        const input = [{ inputs: [], type: 'function', constant: true }];
+        st.deepEqual(abi_1.default.update('0.3.6', input), [{ inputs: [], constant: true, stateMutability: 'view', type: 'function' }, { payable: true, stateMutability: 'payable', type: 'fallback' }]);
+        st.end();
+    });
+    t.test('0.3.6 (event)', function (st) {
+        const input = [{ inputs: [], type: 'event' }];
+        st.deepEqual(abi_1.default.update('0.3.6', input), [{ inputs: [], type: 'event' }, { payable: true, stateMutability: 'payable', type: 'fallback' }]);
+        st.end();
+    });
+    t.test('0.3.6 (has no fallback)', function (st) {
+        const input = [{ inputs: [], type: 'constructor' }];
+        st.deepEqual(abi_1.default.update('0.3.6', input), [{ inputs: [], type: 'constructor', payable: true, stateMutability: 'payable' }, { type: 'fallback', payable: true, stateMutability: 'payable' }]);
+        st.end();
+    });
+    t.test('0.4.0 (has fallback)', function (st) {
+        const input = [{ inputs: [], type: 'constructor' }, { type: 'fallback' }];
+        st.deepEqual(abi_1.default.update('0.4.0', input), [{ inputs: [], type: 'constructor', payable: true, stateMutability: 'payable' }, { type: 'fallback', stateMutability: 'nonpayable' }]);
+        st.end();
+    });
+    t.test('0.4.0 (non-constant function)', function (st) {
+        const input = [{ inputs: [], type: 'function' }];
+        st.deepEqual(abi_1.default.update('0.4.0', input), [{ inputs: [], stateMutability: 'nonpayable', type: 'function' }]);
+        st.end();
+    });
+    t.test('0.4.0 (constant function)', function (st) {
+        const input = [{ inputs: [], type: 'function', constant: true }];
+        st.deepEqual(abi_1.default.update('0.4.0', input), [{ inputs: [], constant: true, stateMutability: 'view', type: 'function' }]);
+        st.end();
+    });
+    t.test('0.4.0 (payable function)', function (st) {
+        const input = [{ inputs: [], payable: true, type: 'function' }];
+        st.deepEqual(abi_1.default.update('0.4.0', input), [{ inputs: [], payable: true, stateMutability: 'payable', type: 'function' }]);
+        st.end();
+    });
+    t.test('0.4.1 (constructor not payable)', function (st) {
+        const input = [{ inputs: [], payable: false, type: 'constructor' }];
+        st.deepEqual(abi_1.default.update('0.4.1', input), [{ inputs: [], payable: true, stateMutability: 'payable', type: 'constructor' }]);
+        st.end();
+    });
+    t.test('0.4.5 (constructor payable)', function (st) {
+        const input = [{ inputs: [], payable: false, type: 'constructor' }];
+        st.deepEqual(abi_1.default.update('0.4.5', input), [{ inputs: [], payable: false, stateMutability: 'nonpayable', type: 'constructor' }]);
+        st.end();
+    });
+    t.test('0.4.16 (statemutability)', function (st) {
+        const input = [{ inputs: [], payable: false, stateMutability: 'pure', type: 'function' }];
+        st.deepEqual(abi_1.default.update('0.4.16', input), [{ inputs: [], payable: false, stateMutability: 'pure', type: 'function' }]);
+        st.end();
+    });
+});