@theqrl/hypc 0.0.2 → 0.3.1

package/wrapper.js

@@ -1,20 +1,161 @@
 "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 () {
+    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 };
 };
-const memorystream_1 = __importDefault(require("memorystream"));
+const crypto_1 = require("crypto");
 const follow_redirects_1 = require("follow-redirects");
+const fs = __importStar(require("fs"));
+const js_sha3_1 = require("js-sha3");
+const path = __importStar(require("path"));
 const formatters_1 = require("./formatters");
 const helpers_1 = require("./common/helpers");
 const bindings_1 = __importDefault(require("./bindings"));
 const translate_1 = __importDefault(require("./translate"));
 const Module = module.constructor;
-function wrapper(hypjson) {
-    const { coreBindings, compileBindings, methodFlags } = (0, bindings_1.default)(hypjson);
+/**
+ * Wraps an Emscripten compiler module in the hypc-js API.
+ *
+ * A JavaScript exception that unwinds through the compiler's wasm frames, such as the RangeError
+ * of a stack overflow inside the compiler, leaves that module instance unable to compile (see
+ * `guarded` in bindings/compile.ts). `compile` throws the exception, and the next compilation
+ * runs on a fresh instance of the module, which `reload` returns. By default a module that
+ * `require` loaded is reloaded from its file, and `loadRemoteVersion` reloads from the downloaded
+ * source. Where neither applies, as in a browser or a bundle, pass a function that returns a fresh
+ * module. Without one, the same instance goes on once the compiler has discarded the abandoned
+ * compilation, which compilers from 0.3.0 on do in hyperion_reset(); with an older compiler, or
+ * after a WebAssembly trap, the next compilation returns an error that says the module cannot be
+ * used again.
+ *
+ * @param hypjson The Emscripten compiled Hyperion object.
+ * @param reload Returns a fresh instance of the same module.
+ */
+function wrapper(hypjson, reload = reloaderFor(hypjson)) {
+    let bindings = (0, bindings_1.default)(hypjson);
+    const { methodFlags } = bindings;
+    // Why no compilation can run any more, once that is certain: the instance cannot compile, and no
+    // fresh one can be loaded.
+    let unusable;
+    // Set while the instance goes on after discarding an abandoned compilation and its next output
+    // has not yet shown whether the compiler supports that; holds why it was needed.
+    let recoveringInPlace;
+    const withoutReplacement = (why) => `The compiler module cannot be used again: ${why}. Load a fresh module, or pass a function that does so as the second argument of setupMethods.`;
+    // The bindings of the current module instance, after an exception unwound through the previous
+    // one: of a fresh instance where one can be loaded, otherwise of the same instance after asking
+    // it to discard the abandoned compilation. Throws when neither is possible.
+    function usableBindings() {
+        if (unusable !== undefined) {
+            throw new Error(unusable);
+        }
+        if (!bindings.poisoned) {
+            return bindings;
+        }
+        const why = `an exception unwound through the compiler during an earlier compilation (${(0, helpers_1.describeException)(bindings.poisonedBy)})`;
+        if (reload !== undefined) {
+            try {
+                bindings = (0, bindings_1.default)(reload());
+            }
+            catch (e) {
+                throw new Error(`The compiler module cannot be used again: ${why}, and reloading it failed: ${(0, helpers_1.describeException)(e)}`);
+            }
+            return bindings;
+        }
+        // No fresh instance can be loaded here, as in a browser or a bundle. A JavaScript exception
+        // leaves the instance's memory intact, and hyperion_reset() of compilers from 0.3.0 on
+        // discards the abandoned compilation's state, so the same instance can go on; whether this
+        // compiler does that shows in its next output (see compileMethod). What the abandoned
+        // compilation allocated stays allocated, since its destructors never ran and cannot be run
+        // now, which is why a fresh instance is preferred wherever one can be loaded. After a trap (a
+        // WebAssembly.RuntimeError, which is also what an Emscripten abort throws) the memory cannot
+        // be trusted.
+        if (typeof WebAssembly !== 'undefined' && bindings.poisonedBy instanceof WebAssembly.RuntimeError) {
+            unusable = withoutReplacement(`${why}, and the instance cannot be reused after a WebAssembly trap`);
+            throw new Error(unusable);
+        }
+        if ((0, helpers_1.isNil)(bindings.coreBindings.reset)) {
+            unusable = withoutReplacement(`${why}, and this compiler has no hyperion_reset() to discard it with`);
+            throw new Error(unusable);
+        }
+        try {
+            bindings.coreBindings.reset();
+        }
+        catch (e) {
+            unusable = withoutReplacement(`${why}, and hyperion_reset() failed afterwards: ${(0, helpers_1.describeException)(e)}`);
+            throw new Error(unusable);
+        }
+        bindings.poisoned = false;
+        bindings.poisonedBy = undefined;
+        recoveringInPlace = why;
+        return bindings;
+    }
+    // The compile method of that name, run on the current module instance, or null if the compiler
+    // lacks the method.
+    function compileMethod(name) {
+        if ((0, helpers_1.isNil)(bindings.compileBindings[name])) {
+            return null;
+        }
+        return function (...args) {
+            let current;
+            try {
+                current = usableBindings();
+            }
+            catch (e) {
+                return (0, formatters_1.formatFatalError)(e.message);
+            }
+            const output = current.compileBindings[name](...args);
+            if (recoveringInPlace !== undefined) {
+                const why = recoveringInPlace;
+                recoveringInPlace = undefined;
+                if (reportsStaleCompilerStack(output)) {
+                    unusable = withoutReplacement(`${why}, and this compiler's hyperion_reset() does not discard the abandoned compilation (compilers from 0.3.0 on do)`);
+                    return (0, formatters_1.formatFatalError)(unusable);
+                }
+            }
+            return output;
+        };
+    }
+    const compileBindings = {
+        compileJson: compileMethod('compileJson'),
+        compileJsonCallback: compileMethod('compileJsonCallback'),
+        compileJsonMulti: compileMethod('compileJsonMulti'),
+        compileStandard: compileMethod('compileStandard')
+    };
     return {
-        version: coreBindings.version,
-        semver: coreBindings.versionToSemver,
-        license: coreBindings.license,
+        version: () => bindings.coreBindings.version(),
+        semver: () => bindings.coreBindings.versionToSemver(),
+        license: () => bindings.coreBindings.license(),
         lowlevel: {
             compileSingle: compileBindings.compileJson,
             compileMulti: compileBindings.compileJsonMulti,
@@ -28,36 +169,170 @@ function wrapper(hypjson) {
             nativeStandardJSON: methodFlags.compileJsonStandardSupported
         },
         compile: compileStandardWrapper.bind(this, compileBindings),
-        // Loads the compiler of the given version from the github repository
-        // instead of from the local filesystem.
+        // Loads the compiler of the given version from binaries.theqrl.org instead of from the
+        // local filesystem, after checking it against list.json.
         loadRemoteVersion,
         // Use this if you want to add wrapper functions around the pure module.
         setupMethods: wrapper
     };
 }
-function loadRemoteVersion(versionString, callback) {
-    const memoryStream = new memorystream_1.default(null, { readable: false });
-    const url = `https://binaries.theqrl.org/bin/hypjson-${versionString}.js`;
-    follow_redirects_1.https.get(url, response => {
+// Loads the source of a compiler module as require() does, in a Module of its own that is in
+// neither require.cache nor module.children, so that an instance can be dropped once it is no
+// longer usable. Emscripten's Node support adds a process-wide `unhandledRejection` listener on
+// every load, which would accumulate and keep every instance alive; the listeners a load adds are
+// removed again.
+function loadModuleSource(source, filename) {
+    const events = ['uncaughtException', 'unhandledRejection'];
+    const listenersBefore = events.map(event => process.listeners(event));
+    try {
+        const hypjson = new Module(filename);
+        hypjson.filename = filename;
+        hypjson.paths = Module._nodeModulePaths(path.dirname(filename));
+        hypjson._compile(source, filename);
+        hypjson.loaded = true;
+        return hypjson.exports;
+    }
+    finally {
+        events.forEach((event, i) => {
+            for (const listener of process.listeners(event)) {
+                if (!listenersBefore[i].includes(listener)) {
+                    process.removeListener(event, listener);
+                }
+            }
+        });
+    }
+}
+// A function that loads a fresh instance of a module that require() loaded, found through
+// require.cache; undefined where there is no such record, as in a browser or a bundle.
+function reloaderFor(hypjson) {
+    const cache = typeof require === 'function' ? require.cache : undefined;
+    if (!cache) {
+        return undefined;
+    }
+    const record = Object.keys(cache)
+        .map(key => cache[key])
+        .find(entry => entry && entry.exports === hypjson && typeof entry.filename === 'string');
+    if (!record) {
+        return undefined;
+    }
+    return () => loadModuleSource(fs.readFileSync(record.filename, 'utf8'), record.filename);
+}
+// True if the compiler's output reports the CompilerStack of an abandoned compilation, which is
+// what an instance whose hyperion_reset() did not discard it answers to every compilation.
+function reportsStaleCompilerStack(output) {
+    let parsed;
+    try {
+        parsed = JSON.parse(output);
+    }
+    catch (e) {
+        return false;
+    }
+    const errors = parsed && parsed.errors;
+    return Array.isArray(errors) && errors.some(error => {
+        // Compilers before 0.4.x reported errors as strings.
+        const message = typeof error === 'string' ? error : error && error.message;
+        const internal = typeof error === 'string' || (error && error.type === 'InternalCompilerError');
+        return internal && typeof message === 'string' && message.includes('You shall not have another CompilerStack aside me.');
+    });
+}
+const BINARIES_HOST = 'binaries.theqrl.org';
+const BINARIES_URL = `https://${BINARIES_HOST}/bin/`;
+// list.json is a few kilobytes and a compiler build about 9 MB.
+const MAX_LIST_BYTES = 1024 * 1024;
+const MAX_BUILD_BYTES = 64 * 1024 * 1024;
+// Follow redirects only to https URLs on the binaries host.
+function beforeRedirect(options) {
+    if (options.protocol !== 'https:' || options.hostname !== BINARIES_HOST) {
+        throw new Error(`Refusing to follow a redirect to ${options.protocol}//${options.hostname}.`);
+    }
+}
+// Calls back once, with an error or the complete body of a 200 response.
+function download(url, maxBytes, callback) {
+    let done = false;
+    const finish = (error, body) => {
+        if (!done) {
+            done = true;
+            callback(error, body);
+        }
+    };
+    follow_redirects_1.https.get(url, { beforeRedirect, maxRedirects: 5 }, response => {
         if (response.statusCode !== 200) {
-            callback(new Error(`Error retrieving binary: ${response.statusMessage}`));
+            response.resume();
+            finish(new Error(`Error retrieving ${url}: ${response.statusCode} ${response.statusMessage}`));
+            return;
         }
-        else {
-            response.pipe(memoryStream);
-            response.on('end', () => {
-                // Based on the require-from-string package.
-                const hypjson = new Module();
-                hypjson._compile(memoryStream.toString(), `hypjson-${versionString}.js`);
-                if (module.parent && module.parent.children) {
-                    // Make sure the module is plugged into the hierarchy correctly to have parent
-                    // properly garbage collected.
-                    module.parent.children.splice(module.parent.children.indexOf(hypjson), 1);
-                }
-                callback(null, wrapper(hypjson.exports));
-            });
+        const chunks = [];
+        let length = 0;
+        response.on('data', chunk => {
+            length += chunk.length;
+            if (length > maxBytes) {
+                response.destroy();
+                finish(new Error(`${url} is larger than ${maxBytes} bytes.`));
+            }
+            else {
+                chunks.push(chunk);
+            }
+        });
+        response.on('end', () => finish(null, Buffer.concat(chunks)));
+        response.on('error', finish);
+    }).on('error', finish);
+}
+// The list.json entry for "latest", a release such as "0.2.0", or a build such as
+// "v0.2.0+commit.e36a0aea".
+function findBuild(list, versionString) {
+    const releases = list.releases || {};
+    const buildPath = versionString === 'latest'
+        ? releases[list.latestRelease]
+        : releases[versionString] || `hypjson-${versionString}.js`;
+    const build = (list.builds || []).find(entry => entry.path === buildPath);
+    if (!build ||
+        !/^hypjson-v[0-9A-Za-z.+-]+\.js$/.test(build.path) ||
+        typeof build.keccak256 !== 'string' ||
+        typeof build.sha256 !== 'string') {
+        throw new Error(`Version ${versionString} is not in ${BINARIES_URL}list.json.`);
+    }
+    return build;
+}
+// Downloads a compiler build and runs it only if its keccak256 and sha256 match list.json.
+function loadRemoteVersion(versionString, callback) {
+    download(BINARIES_URL + 'list.json', MAX_LIST_BYTES, (listError, listBody) => {
+        if (listError) {
+            callback(listError);
+            return;
+        }
+        let build;
+        try {
+            build = findBuild(JSON.parse(listBody.toString('utf8')), versionString);
+        }
+        catch (e) {
+            callback(e);
+            return;
         }
-    }).on('error', function (error) {
-        callback(error);
+        download(BINARIES_URL + build.path, MAX_BUILD_BYTES, (error, body) => {
+            if (error) {
+                callback(error);
+                return;
+            }
+            const keccak = '0x' + (0, js_sha3_1.keccak256)(body);
+            const sha256 = '0x' + (0, crypto_1.createHash)('sha256').update(body).digest('hex');
+            if (keccak !== build.keccak256.toLowerCase() || sha256 !== build.sha256.toLowerCase()) {
+                callback(new Error(`${build.path} does not match the keccak256 and sha256 in list.json, so it was not run.`));
+                return;
+            }
+            let hypc;
+            try {
+                // The source stays referenced so that a fresh instance can be loaded if an exception
+                // unwinds through this one (see wrapper).
+                const source = body.toString('utf8');
+                const load = () => loadModuleSource(source, build.path);
+                hypc = wrapper(load(), load);
+            }
+            catch (e) {
+                callback(e);
+                return;
+            }
+            callback(null, hypc);
+        });
     });
 }
 // Expects a Standard JSON I/O but supports old compilers
@@ -87,12 +362,12 @@ function compileStandardWrapper(compile, inputRaw, readCallback) {
     }
     // Try to wrap around old versions
     if (!(0, helpers_1.isNil)(compile.compileJsonCallback)) {
-        const inputJson = JSON.stringify({ sources: sources });
+        const inputJson = JSON.stringify({ sources });
         const output = compile.compileJsonCallback(inputJson, optimize, readCallback);
         return translateOutput(output, libraries);
     }
     if (!(0, helpers_1.isNil)(compile.compileJsonMulti)) {
-        const output = compile.compileJsonMulti(JSON.stringify({ sources: sources }), optimize);
+        const output = compile.compileJsonMulti(JSON.stringify({ sources }), optimize);
         return translateOutput(output, libraries);
     }
     // Try our luck with an ancient compiler

package/build/clean.js

@@ -1,6 +0,0 @@
-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

@@ -1,10 +0,0 @@
-// 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

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

package/contractA_hyp_A.bin

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

package/contractB_hyp_B.bin

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

package/importA_hyp_C.bin

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

package/importB_hyp_D.bin

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

package/libX_hyp_X.bin

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

package/libY_hyp_Y.bin

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

package/libZ_hyp_Z.bin

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

package/test/abi.js

@@ -1,77 +0,0 @@
-"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();
-    });
-});