@gearbox-protocol/deploy-tools 1.1.4 → 1.2.0

package/dist/index.js

@@ -167,7 +167,7 @@ var require_argument = __commonJS({
       /**
        * Set the default value, and optionally supply the description to be displayed in the help.
        *
-       * @param {any} value
+       * @param {*} value
        * @param {string} [description]
        * @return {Argument}
        */
@@ -312,8 +312,8 @@ var require_help = __commonJS({
         if (!this.showGlobalOptions)
           return [];
         const globalOptions = [];
-        for (let parentCmd = cmd.parent; parentCmd; parentCmd = parentCmd.parent) {
-          const visibleOptions = parentCmd.options.filter((option) => !option.hidden);
+        for (let ancestorCmd = cmd.parent; ancestorCmd; ancestorCmd = ancestorCmd.parent) {
+          const visibleOptions = ancestorCmd.options.filter((option) => !option.hidden);
           globalOptions.push(...visibleOptions);
         }
         if (this.sortOptions) {
@@ -329,12 +329,12 @@ var require_help = __commonJS({
        */
       visibleArguments(cmd) {
         if (cmd._argsDescription) {
-          cmd._args.forEach((argument) => {
+          cmd.registeredArguments.forEach((argument) => {
             argument.description = argument.description || cmd._argsDescription[argument.name()] || "";
           });
         }
-        if (cmd._args.find((argument) => argument.description)) {
-          return cmd._args;
+        if (cmd.registeredArguments.find((argument) => argument.description)) {
+          return cmd.registeredArguments;
         }
         return [];
       }
@@ -345,7 +345,7 @@ var require_help = __commonJS({
        * @returns {string}
        */
       subcommandTerm(cmd) {
-        const args = cmd._args.map((arg) => humanReadableArgName(arg)).join(" ");
+        const args = cmd.registeredArguments.map((arg) => humanReadableArgName(arg)).join(" ");
         return cmd._name + (cmd._aliases[0] ? "|" + cmd._aliases[0] : "") + (cmd.options.length ? " [options]" : "") + // simplistic check for non-help option
         (args ? " " + args : "");
       }
@@ -426,11 +426,11 @@ var require_help = __commonJS({
         if (cmd._aliases[0]) {
           cmdName = cmdName + "|" + cmd._aliases[0];
         }
-        let parentCmdNames = "";
-        for (let parentCmd = cmd.parent; parentCmd; parentCmd = parentCmd.parent) {
-          parentCmdNames = parentCmd.name() + " " + parentCmdNames;
+        let ancestorCmdNames = "";
+        for (let ancestorCmd = cmd.parent; ancestorCmd; ancestorCmd = ancestorCmd.parent) {
+          ancestorCmdNames = ancestorCmd.name() + " " + ancestorCmdNames;
         }
-        return parentCmdNames + cmdName + " " + cmd.usage();
+        return ancestorCmdNames + cmdName + " " + cmd.usage();
       }
       /**
        * Get the description for the command.
@@ -654,7 +654,7 @@ var require_option = __commonJS({
       /**
        * Set the default value, and optionally supply the description to be displayed in the help.
        *
-       * @param {any} value
+       * @param {*} value
        * @param {string} [description]
        * @return {Option}
        */
@@ -671,7 +671,7 @@ var require_option = __commonJS({
        * new Option('--color').default('GREYSCALE').preset('RGB');
        * new Option('--donate [amount]').preset('20').argParser(parseFloat);
        *
-       * @param {any} arg
+       * @param {*} arg
        * @return {Option}
        */
       preset(arg) {
@@ -852,7 +852,7 @@ var require_option = __commonJS({
       /**
        * Did the value come from the option, and not from possible matching dual option?
        *
-       * @param {any} value
+       * @param {*} value
        * @param {Option} option
        * @returns {boolean}
        */
@@ -997,7 +997,8 @@ var require_command = __commonJS({
         this.parent = null;
         this._allowUnknownOption = false;
         this._allowExcessArguments = true;
-        this._args = [];
+        this.registeredArguments = [];
+        this._args = this.registeredArguments;
         this.args = [];
         this.rawArgs = [];
         this.processedArgs = [];
@@ -1069,6 +1070,17 @@ var require_command = __commonJS({
         this._showSuggestionAfterError = sourceCommand._showSuggestionAfterError;
         return this;
       }
+      /**
+       * @returns {Command[]}
+       * @api private
+       */
+      _getCommandAndAncestors() {
+        const result = [];
+        for (let command = this; command; command = command.parent) {
+          result.push(command);
+        }
+        return result;
+      }
       /**
        * Define a command.
        *
@@ -1286,14 +1298,14 @@ var require_command = __commonJS({
        * @return {Command} `this` command for chaining
        */
       addArgument(argument) {
-        const previousArgument = this._args.slice(-1)[0];
+        const previousArgument = this.registeredArguments.slice(-1)[0];
         if (previousArgument && previousArgument.variadic) {
           throw new Error(`only the last argument can be variadic '${previousArgument.name()}'`);
         }
         if (argument.required && argument.defaultValue !== void 0 && argument.parseArg === void 0) {
           throw new Error(`a default value for a required argument is never used: '${argument.name()}'`);
         }
-        this._args.push(argument);
+        this.registeredArguments.push(argument);
         return this;
       }
       /**
@@ -1398,7 +1410,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        */
       action(fn) {
         const listener = (args) => {
-          const expectedArgsCount = this._args.length;
+          const expectedArgsCount = this.registeredArguments.length;
           const actionArgs = args.slice(0, expectedArgsCount);
           if (this._storeOptionsAsProperties) {
             actionArgs[expectedArgsCount] = this;
@@ -1424,6 +1436,26 @@ Expecting one of '${allowedValues.join("', '")}'`);
       createOption(flags, description) {
         return new Option2(flags, description);
       }
+      /**
+       * Wrap parseArgs to catch 'commander.invalidArgument'.
+       *
+       * @param {Option | Argument} target
+       * @param {string} value
+       * @param {*} previous
+       * @param {string} invalidArgumentMessage
+       * @api private
+       */
+      _callParseArg(target, value, previous, invalidArgumentMessage) {
+        try {
+          return target.parseArg(value, previous);
+        } catch (err) {
+          if (err.code === "commander.invalidArgument") {
+            const message = `${invalidArgumentMessage} ${err.message}`;
+            this.error(message, { exitCode: err.exitCode, code: err.code });
+          }
+          throw err;
+        }
+      }
       /**
        * Add an option.
        *
@@ -1448,15 +1480,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           }
           const oldValue = this.getOptionValue(name);
           if (val !== null && option.parseArg) {
-            try {
-              val = option.parseArg(val, oldValue);
-            } catch (err) {
-              if (err.code === "commander.invalidArgument") {
-                const message = `${invalidValueMessage} ${err.message}`;
-                this.error(message, { exitCode: err.exitCode, code: err.code });
-              }
-              throw err;
-            }
+            val = this._callParseArg(option, val, oldValue, invalidValueMessage);
           } else if (val !== null && option.variadic) {
             val = option._concatValue(val, oldValue);
           }
@@ -1509,56 +1533,28 @@ Expecting one of '${allowedValues.join("', '")}'`);
         return this.addOption(option);
       }
       /**
-       * Define option with `flags`, `description` and optional
-       * coercion `fn`.
+       * Define option with `flags`, `description`, and optional argument parsing function or `defaultValue` or both.
        *
-       * The `flags` string contains the short and/or long flags,
-       * separated by comma, a pipe or space. The following are all valid
-       * all will output this way when `--help` is used.
+       * The `flags` string contains the short and/or long flags, separated by comma, a pipe or space. A required
+       * option-argument is indicated by `<>` and an optional option-argument by `[]`.
        *
-       *     "-p, --pepper"
-       *     "-p|--pepper"
-       *     "-p --pepper"
+       * See the README for more details, and see also addOption() and requiredOption().
        *
        * @example
-       * // simple boolean defaulting to undefined
-       * program.option('-p, --pepper', 'add pepper');
-       *
-       * program.pepper
-       * // => undefined
-       *
-       * --pepper
-       * program.pepper
-       * // => true
-       *
-       * // simple boolean defaulting to true (unless non-negated option is also defined)
-       * program.option('-C, --no-cheese', 'remove cheese');
-       *
-       * program.cheese
-       * // => true
-       *
-       * --no-cheese
-       * program.cheese
-       * // => false
-       *
-       * // required argument
-       * program.option('-C, --chdir <path>', 'change the working directory');
-       *
-       * --chdir /tmp
-       * program.chdir
-       * // => "/tmp"
-       *
-       * // optional argument
-       * program.option('-c, --cheese [type]', 'add cheese [marble]');
+       * program
+       *     .option('-p, --pepper', 'add pepper')
+       *     .option('-p, --pizza-type <TYPE>', 'type of pizza') // required option-argument
+       *     .option('-c, --cheese [CHEESE]', 'add extra cheese', 'mozzarella') // optional option-argument with default
+       *     .option('-t, --tip <VALUE>', 'add tip to purchase cost', parseFloat) // custom parse function
        *
        * @param {string} flags
        * @param {string} [description]
-       * @param {Function|*} [fn] - custom option processing function or default value
+       * @param {Function|*} [parseArg] - custom option processing function or default value
        * @param {*} [defaultValue]
        * @return {Command} `this` command for chaining
        */
-      option(flags, description, fn, defaultValue) {
-        return this._optionEx({}, flags, description, fn, defaultValue);
+      option(flags, description, parseArg, defaultValue) {
+        return this._optionEx({}, flags, description, parseArg, defaultValue);
       }
       /**
       * Add a required option which must have a value after parsing. This usually means
@@ -1568,12 +1564,12 @@ Expecting one of '${allowedValues.join("', '")}'`);
       *
       * @param {string} flags
       * @param {string} [description]
-      * @param {Function|*} [fn] - custom option processing function or default value
+      * @param {Function|*} [parseArg] - custom option processing function or default value
       * @param {*} [defaultValue]
       * @return {Command} `this` command for chaining
       */
-      requiredOption(flags, description, fn, defaultValue) {
-        return this._optionEx({ mandatory: true }, flags, description, fn, defaultValue);
+      requiredOption(flags, description, parseArg, defaultValue) {
+        return this._optionEx({ mandatory: true }, flags, description, parseArg, defaultValue);
       }
       /**
        * Alter parsing of short flags with optional values.
@@ -1644,10 +1640,10 @@ Expecting one of '${allowedValues.join("', '")}'`);
         * @return {Command} `this` command for chaining
         */
       storeOptionsAsProperties(storeAsProperties = true) {
-        this._storeOptionsAsProperties = !!storeAsProperties;
         if (this.options.length) {
           throw new Error("call .storeOptionsAsProperties() before adding options");
         }
+        this._storeOptionsAsProperties = !!storeAsProperties;
         return this;
       }
       /**
@@ -1708,7 +1704,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         */
       getOptionValueSourceWithGlobals(key) {
         let source;
-        getCommandAndParents(this).forEach((cmd) => {
+        this._getCommandAndAncestors().forEach((cmd) => {
           if (cmd.getOptionValueSource(key) !== void 0) {
             source = cmd.getOptionValueSource(key);
           }
@@ -1907,16 +1903,16 @@ Expecting one of '${allowedValues.join("', '")}'`);
         const subCommand = this._findCommand(commandName);
         if (!subCommand)
           this.help({ error: true });
-        let hookResult;
-        hookResult = this._chainOrCallSubCommandHook(hookResult, subCommand, "preSubcommand");
-        hookResult = this._chainOrCall(hookResult, () => {
+        let promiseChain;
+        promiseChain = this._chainOrCallSubCommandHook(promiseChain, subCommand, "preSubcommand");
+        promiseChain = this._chainOrCall(promiseChain, () => {
           if (subCommand._executableHandler) {
             this._executeSubCommand(subCommand, operands.concat(unknown));
           } else {
             return subCommand._parseCommand(operands, unknown);
           }
         });
-        return hookResult;
+        return promiseChain;
       }
       /**
        * Invoke help directly if possible, or dispatch if necessary.
@@ -1932,28 +1928,30 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (subCommand && !subCommand._executableHandler) {
           subCommand.help();
         }
-        return this._dispatchSubcommand(subcommandName, [], [this._helpLongFlag]);
+        return this._dispatchSubcommand(subcommandName, [], [
+          this._helpLongFlag || this._helpShortFlag
+        ]);
       }
       /**
-       * Check this.args against expected this._args.
+       * Check this.args against expected this.registeredArguments.
        *
        * @api private
        */
       _checkNumberOfArguments() {
-        this._args.forEach((arg, i) => {
+        this.registeredArguments.forEach((arg, i) => {
           if (arg.required && this.args[i] == null) {
             this.missingArgument(arg.name());
           }
         });
-        if (this._args.length > 0 && this._args[this._args.length - 1].variadic) {
+        if (this.registeredArguments.length > 0 && this.registeredArguments[this.registeredArguments.length - 1].variadic) {
           return;
         }
-        if (this.args.length > this._args.length) {
+        if (this.args.length > this.registeredArguments.length) {
           this._excessArguments(this.args);
         }
       }
       /**
-       * Process this.args using this._args and save as this.processedArgs!
+       * Process this.args using this.registeredArguments and save as this.processedArgs!
        *
        * @api private
        */
@@ -1961,21 +1959,14 @@ Expecting one of '${allowedValues.join("', '")}'`);
         const myParseArg = (argument, value, previous) => {
           let parsedValue = value;
           if (value !== null && argument.parseArg) {
-            try {
-              parsedValue = argument.parseArg(value, previous);
-            } catch (err) {
-              if (err.code === "commander.invalidArgument") {
-                const message = `error: command-argument value '${value}' is invalid for argument '${argument.name()}'. ${err.message}`;
-                this.error(message, { exitCode: err.exitCode, code: err.code });
-              }
-              throw err;
-            }
+            const invalidValueMessage = `error: command-argument value '${value}' is invalid for argument '${argument.name()}'.`;
+            parsedValue = this._callParseArg(argument, value, previous, invalidValueMessage);
           }
           return parsedValue;
         };
         this._checkNumberOfArguments();
         const processedArgs = [];
-        this._args.forEach((declaredArg, index) => {
+        this.registeredArguments.forEach((declaredArg, index) => {
           let value = declaredArg.defaultValue;
           if (declaredArg.variadic) {
             if (index < this.args.length) {
@@ -2022,7 +2013,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
       _chainOrCallHooks(promise, event) {
         let result = promise;
         const hooks = [];
-        getCommandAndParents(this).reverse().filter((cmd) => cmd._lifeCycleHooks[event] !== void 0).forEach((hookedCommand) => {
+        this._getCommandAndAncestors().reverse().filter((cmd) => cmd._lifeCycleHooks[event] !== void 0).forEach((hookedCommand) => {
           hookedCommand._lifeCycleHooks[event].forEach((callback) => {
             hooks.push({ hookedCommand, callback });
           });
@@ -2094,16 +2085,16 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (this._actionHandler) {
           checkForUnknownOptions();
           this._processArguments();
-          let actionResult;
-          actionResult = this._chainOrCallHooks(actionResult, "preAction");
-          actionResult = this._chainOrCall(actionResult, () => this._actionHandler(this.processedArgs));
+          let promiseChain;
+          promiseChain = this._chainOrCallHooks(promiseChain, "preAction");
+          promiseChain = this._chainOrCall(promiseChain, () => this._actionHandler(this.processedArgs));
           if (this.parent) {
-            actionResult = this._chainOrCall(actionResult, () => {
+            promiseChain = this._chainOrCall(promiseChain, () => {
               this.parent.emit(commandEvent, operands, unknown);
             });
           }
-          actionResult = this._chainOrCallHooks(actionResult, "postAction");
-          return actionResult;
+          promiseChain = this._chainOrCallHooks(promiseChain, "postAction");
+          return promiseChain;
         }
         if (this.parent && this.parent.listenerCount(commandEvent)) {
           checkForUnknownOptions();
@@ -2156,13 +2147,13 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @api private
        */
       _checkForMissingMandatoryOptions() {
-        for (let cmd = this; cmd; cmd = cmd.parent) {
+        this._getCommandAndAncestors().forEach((cmd) => {
           cmd.options.forEach((anOption) => {
             if (anOption.mandatory && cmd.getOptionValue(anOption.attributeName()) === void 0) {
               cmd.missingMandatoryOptionValue(anOption);
             }
           });
-        }
+        });
       }
       /**
        * Display an error message if conflicting options are used together in this.
@@ -2198,9 +2189,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @api private
        */
       _checkForConflictingOptions() {
-        for (let cmd = this; cmd; cmd = cmd.parent) {
+        this._getCommandAndAncestors().forEach((cmd) => {
           cmd._checkForConflictingLocalOptions();
-        }
+        });
       }
       /**
        * Parse options from `argv` removing known options,
@@ -2334,7 +2325,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @return {Object}
        */
       optsWithGlobals() {
-        return getCommandAndParents(this).reduce(
+        return this._getCommandAndAncestors().reduce(
           (combinedOptions, cmd) => Object.assign(combinedOptions, cmd.opts()),
           {}
         );
@@ -2490,7 +2481,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
       _excessArguments(receivedArgs) {
         if (this._allowExcessArguments)
           return;
-        const expected = this._args.length;
+        const expected = this.registeredArguments.length;
         const s = expected === 1 ? "" : "s";
         const forSubcommand = this.parent ? ` for '${this.name()}'` : "";
         const message = `error: too many arguments${forSubcommand}. Expected ${expected} argument${s} but got ${receivedArgs.length}.`;
@@ -2517,17 +2508,16 @@ Expecting one of '${allowedValues.join("', '")}'`);
         this.error(message, { code: "commander.unknownCommand" });
       }
       /**
-       * Set the program version to `str`.
+       * Get or set the program version.
        *
-       * This method auto-registers the "-V, --version" flag
-       * which will print the version number when passed.
+       * This method auto-registers the "-V, --version" option which will print the version number.
        *
-       * You can optionally supply the  flags and description to override the defaults.
+       * You can optionally supply the flags and description to override the defaults.
        *
-       * @param {string} str
+       * @param {string} [str]
        * @param {string} [flags]
        * @param {string} [description]
-       * @return {this | string} `this` command for chaining, or version string if no arguments
+       * @return {this | string | undefined} `this` command for chaining, or version string if no arguments
        */
       version(str, flags, description) {
         if (str === void 0)
@@ -2617,13 +2607,13 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (str === void 0) {
           if (this._usage)
             return this._usage;
-          const args = this._args.map((arg) => {
+          const args = this.registeredArguments.map((arg) => {
             return humanReadableArgName(arg);
           });
           return [].concat(
             this.options.length || this._hasHelpOption ? "[options]" : [],
             this.commands.length ? "[command]" : [],
-            this._args.length ? args : []
+            this.registeredArguments.length ? args : []
           ).join(" ");
         }
         this._usage = str;
@@ -2666,7 +2656,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * program.executableDir('subcommands');
        *
        * @param {string} [path]
-       * @return {string|Command}
+       * @return {string|null|Command}
        */
       executableDir(path5) {
         if (path5 === void 0)
@@ -2717,7 +2707,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           contextOptions = void 0;
         }
         const context = this._getHelpContext(contextOptions);
-        getCommandAndParents(this).reverse().forEach((command) => command.emit("beforeAllHelp", context));
+        this._getCommandAndAncestors().reverse().forEach((command) => command.emit("beforeAllHelp", context));
         this.emit("beforeHelp", context);
         let helpInformation = this.helpInformation(context);
         if (deprecatedCallback) {
@@ -2727,9 +2717,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
           }
         }
         context.write(helpInformation);
-        this.emit(this._helpLongFlag);
+        if (this._helpLongFlag) {
+          this.emit(this._helpLongFlag);
+        }
         this.emit("afterHelp", context);
-        getCommandAndParents(this).forEach((command) => command.emit("afterAllHelp", context));
+        this._getCommandAndAncestors().forEach((command) => command.emit("afterAllHelp", context));
       }
       /**
        * You can pass in flags and a description to override the help
@@ -2835,13 +2827,6 @@ Expecting one of '${allowedValues.join("', '")}'`);
         return arg;
       });
     }
-    function getCommandAndParents(startCommand) {
-      const result = [];
-      for (let command = startCommand; command; command = command.parent) {
-        result.push(command);
-      }
-      return result;
-    }
     exports2.Command = Command2;
   }
 });
@@ -2856,13 +2841,13 @@ var require_commander = __commonJS({
     var { Option: Option2 } = require_option();
     exports2 = module2.exports = new Command2();
     exports2.program = exports2;
-    exports2.Argument = Argument2;
     exports2.Command = Command2;
-    exports2.CommanderError = CommanderError2;
+    exports2.Option = Option2;
+    exports2.Argument = Argument2;
     exports2.Help = Help2;
+    exports2.CommanderError = CommanderError2;
     exports2.InvalidArgumentError = InvalidArgumentError2;
     exports2.InvalidOptionArgumentError = InvalidArgumentError2;
-    exports2.Option = Option2;
   }
 });
 
@@ -7112,14 +7097,14 @@ var require_errors = __commonJS({
       return error;
     }
     exports2.makeError = makeError;
-    function assert2(check, message, code, info) {
+    function assert(check, message, code, info) {
       if (!check) {
         throw makeError(message, code, info);
       }
     }
-    exports2.assert = assert2;
+    exports2.assert = assert;
     function assertArgument(check, message, name, value) {
-      assert2(check, message, "INVALID_ARGUMENT", { argument: name, value });
+      assert(check, message, "INVALID_ARGUMENT", { argument: name, value });
     }
     exports2.assertArgument = assertArgument;
     function assertArgumentCount(count, expectedCount, message) {
@@ -7129,11 +7114,11 @@ var require_errors = __commonJS({
       if (message) {
         message = ": " + message;
       }
-      assert2(count >= expectedCount, "missing arguemnt" + message, "MISSING_ARGUMENT", {
+      assert(count >= expectedCount, "missing arguemnt" + message, "MISSING_ARGUMENT", {
         count,
         expectedCount
       });
-      assert2(count <= expectedCount, "too many arguemnts" + message, "UNEXPECTED_ARGUMENT", {
+      assert(count <= expectedCount, "too many arguemnts" + message, "UNEXPECTED_ARGUMENT", {
         count,
         expectedCount
       });
@@ -7158,7 +7143,7 @@ var require_errors = __commonJS({
       return accum;
     }, []);
     function assertNormalize(form) {
-      assert2(_normalizeForms.indexOf(form) >= 0, "platform missing String.prototype.normalize", "UNSUPPORTED_OPERATION", {
+      assert(_normalizeForms.indexOf(form) >= 0, "platform missing String.prototype.normalize", "UNSUPPORTED_OPERATION", {
         operation: "String.prototype.normalize",
         info: { form }
       });
@@ -7174,7 +7159,7 @@ var require_errors = __commonJS({
           method += ".";
           operation += " " + className;
         }
-        assert2(false, `private constructor; use ${method}from* methods`, "UNSUPPORTED_OPERATION", {
+        assert(false, `private constructor; use ${method}from* methods`, "UNSUPPORTED_OPERATION", {
           operation
         });
       }
@@ -10004,7 +9989,7 @@ var require_assert = __commonJS({
       }
     }
     exports2.output = output;
-    var assert2 = {
+    var assert = {
       number,
       bool,
       bytes,
@@ -10012,7 +9997,7 @@ var require_assert = __commonJS({
       exists,
       output
     };
-    exports2.default = assert2;
+    exports2.default = assert;
   }
 });
 
@@ -42624,7 +42609,7 @@ var require_follow_redirects = __commonJS({
     var http = require("http");
     var https = require("https");
     var Writable = require("stream").Writable;
-    var assert2 = require("assert");
+    var assert = require("assert");
     var debug = require_debug2();
     var events = ["abort", "aborted", "connect", "error", "socket", "timeout"];
     var eventHandlers = /* @__PURE__ */ Object.create(null);
@@ -42990,7 +42975,7 @@ var require_follow_redirects = __commonJS({
           if (!isString(options.host) && !isString(options.hostname)) {
             options.hostname = "::1";
           }
-          assert2.equal(options.protocol, protocol, "protocol mismatch");
+          assert.equal(options.protocol, protocol, "protocol mismatch");
           debug("options", options);
           return new RedirectableRequest(options, callback);
         }
@@ -43056,7 +43041,7 @@ var require_follow_redirects = __commonJS({
       request.destroy(error);
     }
     function isSubdomain(subdomain, domain) {
-      assert2(isString(subdomain) && isString(domain));
+      assert(isString(subdomain) && isString(domain));
       var dot = subdomain.length - domain.length - 1;
       return dot > 0 && subdomain[dot] === "." && subdomain.endsWith(domain);
     }
@@ -59918,7 +59903,7 @@ var require_bn = __commonJS({
   "node_modules/bn.js/lib/bn.js"(exports2, module2) {
     (function(module3, exports3) {
       "use strict";
-      function assert2(val, msg) {
+      function assert(val, msg) {
         if (!val)
           throw new Error(msg || "Assertion failed");
       }
@@ -59988,7 +59973,7 @@ var require_bn = __commonJS({
         if (base === "hex") {
           base = 16;
         }
-        assert2(base === (base | 0) && base >= 2 && base <= 36);
+        assert(base === (base | 0) && base >= 2 && base <= 36);
         number = number.toString().replace(/\s+/g, "");
         var start = 0;
         if (number[0] === "-") {
@@ -60021,7 +60006,7 @@ var require_bn = __commonJS({
           ];
           this.length = 2;
         } else {
-          assert2(number < 9007199254740992);
+          assert(number < 9007199254740992);
           this.words = [
             number & 67108863,
             number / 67108864 & 67108863,
@@ -60034,7 +60019,7 @@ var require_bn = __commonJS({
         this._initArray(this.toArray(), base, endian);
       };
       BN.prototype._initArray = function _initArray(number, base, endian) {
-        assert2(typeof number.length === "number");
+        assert(typeof number.length === "number");
         if (number.length <= 0) {
           this.words = [0];
           this.length = 1;
@@ -60081,7 +60066,7 @@ var require_bn = __commonJS({
         } else if (c >= 97 && c <= 102) {
           return c - 87;
         } else {
-          assert2(false, "Invalid character in " + string);
+          assert(false, "Invalid character in " + string);
         }
       }
       function parseHexByte(string, lowerBound, index) {
@@ -60142,7 +60127,7 @@ var require_bn = __commonJS({
           } else {
             b = c;
           }
-          assert2(c >= 0 && b < mul, "Invalid character");
+          assert(c >= 0 && b < mul, "Invalid character");
           r += b;
         }
         return r;
@@ -60402,7 +60387,7 @@ var require_bn = __commonJS({
           }
           return out;
         }
-        assert2(false, "Base should be between 2 and 36");
+        assert(false, "Base should be between 2 and 36");
       };
       BN.prototype.toNumber = function toNumber() {
         var ret = this.words[0];
@@ -60411,7 +60396,7 @@ var require_bn = __commonJS({
         } else if (this.length === 3 && this.words[2] === 1) {
           ret += 4503599627370496 + this.words[1] * 67108864;
         } else if (this.length > 2) {
-          assert2(false, "Number can only safely store up to 53 bits");
+          assert(false, "Number can only safely store up to 53 bits");
         }
         return this.negative !== 0 ? -ret : ret;
       };
@@ -60436,8 +60421,8 @@ var require_bn = __commonJS({
         this._strip();
         var byteLength = this.byteLength();
         var reqLength = length || Math.max(1, byteLength);
-        assert2(byteLength <= reqLength, "byte array longer than desired length");
-        assert2(reqLength > 0, "Requested array length <= 0");
+        assert(byteLength <= reqLength, "byte array longer than desired length");
+        assert(reqLength > 0, "Requested array length <= 0");
         var res = allocate(ArrayType, reqLength);
         var postfix = endian === "le" ? "LE" : "BE";
         this["_toArrayLike" + postfix](res, byteLength);
@@ -60619,7 +60604,7 @@ var require_bn = __commonJS({
         return this._strip();
       };
       BN.prototype.ior = function ior(num) {
-        assert2((this.negative | num.negative) === 0);
+        assert((this.negative | num.negative) === 0);
         return this.iuor(num);
       };
       BN.prototype.or = function or(num) {
@@ -60646,7 +60631,7 @@ var require_bn = __commonJS({
         return this._strip();
       };
       BN.prototype.iand = function iand(num) {
-        assert2((this.negative | num.negative) === 0);
+        assert((this.negative | num.negative) === 0);
         return this.iuand(num);
       };
       BN.prototype.and = function and(num) {
@@ -60681,7 +60666,7 @@ var require_bn = __commonJS({
         return this._strip();
       };
       BN.prototype.ixor = function ixor(num) {
-        assert2((this.negative | num.negative) === 0);
+        assert((this.negative | num.negative) === 0);
         return this.iuxor(num);
       };
       BN.prototype.xor = function xor(num) {
@@ -60695,7 +60680,7 @@ var require_bn = __commonJS({
         return num.clone().iuxor(this);
       };
       BN.prototype.inotn = function inotn(width) {
-        assert2(typeof width === "number" && width >= 0);
+        assert(typeof width === "number" && width >= 0);
         var bytesNeeded = Math.ceil(width / 26) | 0;
         var bitsLeft = width % 26;
         this._expand(bytesNeeded);
@@ -60714,7 +60699,7 @@ var require_bn = __commonJS({
         return this.clone().inotn(width);
       };
       BN.prototype.setn = function setn(bit, val) {
-        assert2(typeof bit === "number" && bit >= 0);
+        assert(typeof bit === "number" && bit >= 0);
         var off = bit / 26 | 0;
         var wbit = bit % 26;
         this._expand(off + 1);
@@ -61580,8 +61565,8 @@ var require_bn = __commonJS({
         for (i = 2 * len; i < N; ++i) {
           rws[i] = 0;
         }
-        assert2(carry === 0);
-        assert2((carry & ~8191) === 0);
+        assert(carry === 0);
+        assert((carry & ~8191) === 0);
       };
       FFTM.prototype.stub = function stub(N) {
         var ph = new Array(N);
@@ -61636,8 +61621,8 @@ var require_bn = __commonJS({
         var isNegNum = num < 0;
         if (isNegNum)
           num = -num;
-        assert2(typeof num === "number");
-        assert2(num < 67108864);
+        assert(typeof num === "number");
+        assert(num < 67108864);
         var carry = 0;
         for (var i = 0; i < this.length; i++) {
           var w = (this.words[i] | 0) * num;
@@ -61681,7 +61666,7 @@ var require_bn = __commonJS({
         return res;
       };
       BN.prototype.iushln = function iushln(bits) {
-        assert2(typeof bits === "number" && bits >= 0);
+        assert(typeof bits === "number" && bits >= 0);
         var r = bits % 26;
         var s = (bits - r) / 26;
         var carryMask = 67108863 >>> 26 - r << 26 - r;
@@ -61711,11 +61696,11 @@ var require_bn = __commonJS({
         return this._strip();
       };
       BN.prototype.ishln = function ishln(bits) {
-        assert2(this.negative === 0);
+        assert(this.negative === 0);
         return this.iushln(bits);
       };
       BN.prototype.iushrn = function iushrn(bits, hint, extended) {
-        assert2(typeof bits === "number" && bits >= 0);
+        assert(typeof bits === "number" && bits >= 0);
         var h;
         if (hint) {
           h = (hint - hint % 26) / 26;
@@ -61760,7 +61745,7 @@ var require_bn = __commonJS({
         return this._strip();
       };
       BN.prototype.ishrn = function ishrn(bits, hint, extended) {
-        assert2(this.negative === 0);
+        assert(this.negative === 0);
         return this.iushrn(bits, hint, extended);
       };
       BN.prototype.shln = function shln(bits) {
@@ -61776,7 +61761,7 @@ var require_bn = __commonJS({
         return this.clone().iushrn(bits);
       };
       BN.prototype.testn = function testn(bit) {
-        assert2(typeof bit === "number" && bit >= 0);
+        assert(typeof bit === "number" && bit >= 0);
         var r = bit % 26;
         var s = (bit - r) / 26;
         var q = 1 << r;
@@ -61786,10 +61771,10 @@ var require_bn = __commonJS({
         return !!(w & q);
       };
       BN.prototype.imaskn = function imaskn(bits) {
-        assert2(typeof bits === "number" && bits >= 0);
+        assert(typeof bits === "number" && bits >= 0);
         var r = bits % 26;
         var s = (bits - r) / 26;
-        assert2(this.negative === 0, "imaskn works only with positive numbers");
+        assert(this.negative === 0, "imaskn works only with positive numbers");
         if (this.length <= s) {
           return this;
         }
@@ -61807,8 +61792,8 @@ var require_bn = __commonJS({
         return this.clone().imaskn(bits);
       };
       BN.prototype.iaddn = function iaddn(num) {
-        assert2(typeof num === "number");
-        assert2(num < 67108864);
+        assert(typeof num === "number");
+        assert(num < 67108864);
         if (num < 0)
           return this.isubn(-num);
         if (this.negative !== 0) {
@@ -61838,8 +61823,8 @@ var require_bn = __commonJS({
         return this;
       };
       BN.prototype.isubn = function isubn(num) {
-        assert2(typeof num === "number");
-        assert2(num < 67108864);
+        assert(typeof num === "number");
+        assert(num < 67108864);
         if (num < 0)
           return this.iaddn(-num);
         if (this.negative !== 0) {
@@ -61893,7 +61878,7 @@ var require_bn = __commonJS({
         }
         if (carry === 0)
           return this._strip();
-        assert2(carry === -1);
+        assert(carry === -1);
         carry = 0;
         for (i = 0; i < this.length; i++) {
           w = -(this.words[i] | 0) + carry;
@@ -61961,7 +61946,7 @@ var require_bn = __commonJS({
         };
       };
       BN.prototype.divmod = function divmod(num, mode, positive) {
-        assert2(!num.isZero());
+        assert(!num.isZero());
         if (this.isZero()) {
           return {
             div: new BN(0),
@@ -62059,7 +62044,7 @@ var require_bn = __commonJS({
         var isNegNum = num < 0;
         if (isNegNum)
           num = -num;
-        assert2(num <= 67108863);
+        assert(num <= 67108863);
         var p = (1 << 26) % num;
         var acc = 0;
         for (var i = this.length - 1; i >= 0; i--) {
@@ -62074,7 +62059,7 @@ var require_bn = __commonJS({
         var isNegNum = num < 0;
         if (isNegNum)
           num = -num;
-        assert2(num <= 67108863);
+        assert(num <= 67108863);
         var carry = 0;
         for (var i = this.length - 1; i >= 0; i--) {
           var w = (this.words[i] | 0) + carry * 67108864;
@@ -62088,8 +62073,8 @@ var require_bn = __commonJS({
         return this.clone().idivn(num);
       };
       BN.prototype.egcd = function egcd(p) {
-        assert2(p.negative === 0);
-        assert2(!p.isZero());
+        assert(p.negative === 0);
+        assert(!p.isZero());
         var x = this;
         var y = p.clone();
         if (x.negative !== 0) {
@@ -62153,8 +62138,8 @@ var require_bn = __commonJS({
         };
       };
       BN.prototype._invmp = function _invmp(p) {
-        assert2(p.negative === 0);
-        assert2(!p.isZero());
+        assert(p.negative === 0);
+        assert(!p.isZero());
         var a = this;
         var b = p.clone();
         if (a.negative !== 0) {
@@ -62252,7 +62237,7 @@ var require_bn = __commonJS({
         return this.words[0] & num;
       };
       BN.prototype.bincn = function bincn(bit) {
-        assert2(typeof bit === "number");
+        assert(typeof bit === "number");
         var r = bit % 26;
         var s = (bit - r) / 26;
         var q = 1 << r;
@@ -62292,7 +62277,7 @@ var require_bn = __commonJS({
           if (negative) {
             num = -num;
           }
-          assert2(num <= 67108863, "Number is too big");
+          assert(num <= 67108863, "Number is too big");
           var w = this.words[0] | 0;
           res = w === num ? 0 : w < num ? -1 : 1;
         }
@@ -62364,12 +62349,12 @@ var require_bn = __commonJS({
         return new Red(num);
       };
       BN.prototype.toRed = function toRed(ctx) {
-        assert2(!this.red, "Already a number in reduction context");
-        assert2(this.negative === 0, "red works only with positives");
+        assert(!this.red, "Already a number in reduction context");
+        assert(this.negative === 0, "red works only with positives");
         return ctx.convertTo(this)._forceRed(ctx);
       };
       BN.prototype.fromRed = function fromRed() {
-        assert2(this.red, "fromRed works only with numbers in reduction context");
+        assert(this.red, "fromRed works only with numbers in reduction context");
         return this.red.convertFrom(this);
       };
       BN.prototype._forceRed = function _forceRed(ctx) {
@@ -62377,66 +62362,66 @@ var require_bn = __commonJS({
         return this;
       };
       BN.prototype.forceRed = function forceRed(ctx) {
-        assert2(!this.red, "Already a number in reduction context");
+        assert(!this.red, "Already a number in reduction context");
         return this._forceRed(ctx);
       };
       BN.prototype.redAdd = function redAdd(num) {
-        assert2(this.red, "redAdd works only with red numbers");
+        assert(this.red, "redAdd works only with red numbers");
         return this.red.add(this, num);
       };
       BN.prototype.redIAdd = function redIAdd(num) {
-        assert2(this.red, "redIAdd works only with red numbers");
+        assert(this.red, "redIAdd works only with red numbers");
         return this.red.iadd(this, num);
       };
       BN.prototype.redSub = function redSub(num) {
-        assert2(this.red, "redSub works only with red numbers");
+        assert(this.red, "redSub works only with red numbers");
         return this.red.sub(this, num);
       };
       BN.prototype.redISub = function redISub(num) {
-        assert2(this.red, "redISub works only with red numbers");
+        assert(this.red, "redISub works only with red numbers");
         return this.red.isub(this, num);
       };
       BN.prototype.redShl = function redShl(num) {
-        assert2(this.red, "redShl works only with red numbers");
+        assert(this.red, "redShl works only with red numbers");
         return this.red.shl(this, num);
       };
       BN.prototype.redMul = function redMul(num) {
-        assert2(this.red, "redMul works only with red numbers");
+        assert(this.red, "redMul works only with red numbers");
         this.red._verify2(this, num);
         return this.red.mul(this, num);
       };
       BN.prototype.redIMul = function redIMul(num) {
-        assert2(this.red, "redMul works only with red numbers");
+        assert(this.red, "redMul works only with red numbers");
         this.red._verify2(this, num);
         return this.red.imul(this, num);
       };
       BN.prototype.redSqr = function redSqr() {
-        assert2(this.red, "redSqr works only with red numbers");
+        assert(this.red, "redSqr works only with red numbers");
         this.red._verify1(this);
         return this.red.sqr(this);
       };
       BN.prototype.redISqr = function redISqr() {
-        assert2(this.red, "redISqr works only with red numbers");
+        assert(this.red, "redISqr works only with red numbers");
         this.red._verify1(this);
         return this.red.isqr(this);
       };
       BN.prototype.redSqrt = function redSqrt() {
-        assert2(this.red, "redSqrt works only with red numbers");
+        assert(this.red, "redSqrt works only with red numbers");
         this.red._verify1(this);
         return this.red.sqrt(this);
       };
       BN.prototype.redInvm = function redInvm() {
-        assert2(this.red, "redInvm works only with red numbers");
+        assert(this.red, "redInvm works only with red numbers");
         this.red._verify1(this);
         return this.red.invm(this);
       };
       BN.prototype.redNeg = function redNeg() {
-        assert2(this.red, "redNeg works only with red numbers");
+        assert(this.red, "redNeg works only with red numbers");
         this.red._verify1(this);
         return this.red.neg(this);
       };
       BN.prototype.redPow = function redPow(num) {
-        assert2(this.red && !num.red, "redPow(normalNum)");
+        assert(this.red && !num.red, "redPow(normalNum)");
         this.red._verify1(this);
         return this.red.pow(this, num);
       };
@@ -62604,18 +62589,18 @@ var require_bn = __commonJS({
           this.m = prime.p;
           this.prime = prime;
         } else {
-          assert2(m.gtn(1), "modulus must be greater than 1");
+          assert(m.gtn(1), "modulus must be greater than 1");
           this.m = m;
           this.prime = null;
         }
       }
       Red.prototype._verify1 = function _verify1(a) {
-        assert2(a.negative === 0, "red works only with positives");
-        assert2(a.red, "red works only with red numbers");
+        assert(a.negative === 0, "red works only with positives");
+        assert(a.red, "red works only with red numbers");
       };
       Red.prototype._verify2 = function _verify2(a, b) {
-        assert2((a.negative | b.negative) === 0, "red works only with positives");
-        assert2(
+        assert((a.negative | b.negative) === 0, "red works only with positives");
+        assert(
           a.red && a.red === b.red,
           "red works only with red numbers"
         );
@@ -62686,7 +62671,7 @@ var require_bn = __commonJS({
         if (a.isZero())
           return a.clone();
         var mod3 = this.m.andln(3);
-        assert2(mod3 % 2 === 1);
+        assert(mod3 % 2 === 1);
         if (mod3 === 3) {
           var pow = this.m.add(new BN(1)).iushrn(2);
           return this.pow(a, pow);
@@ -62697,7 +62682,7 @@ var require_bn = __commonJS({
           s++;
           q.iushrn(1);
         }
-        assert2(!q.isZero());
+        assert(!q.isZero());
         var one = new BN(1).toRed(this);
         var nOne = one.redNeg();
         var lpow = this.m.subn(1).iushrn(1);
@@ -62715,7 +62700,7 @@ var require_bn = __commonJS({
           for (var i = 0; tmp.cmp(one) !== 0; i++) {
             tmp = tmp.redSqr();
           }
-          assert2(i < m);
+          assert(i < m);
           var b = this.pow(c, new BN(1).iushln(m - i - 1));
           r = r.redMul(b);
           c = b.redSqr();
@@ -71309,7 +71294,7 @@ var require_bn2 = __commonJS({
   "node_modules/elliptic/node_modules/bn.js/lib/bn.js"(exports2, module2) {
     (function(module3, exports3) {
       "use strict";
-      function assert2(val, msg) {
+      function assert(val, msg) {
         if (!val)
           throw new Error(msg || "Assertion failed");
       }
@@ -71379,7 +71364,7 @@ var require_bn2 = __commonJS({
         if (base === "hex") {
           base = 16;
         }
-        assert2(base === (base | 0) && base >= 2 && base <= 36);
+        assert(base === (base | 0) && base >= 2 && base <= 36);
         number = number.toString().replace(/\s+/g, "");
         var start = 0;
         if (number[0] === "-") {
@@ -71412,7 +71397,7 @@ var require_bn2 = __commonJS({
           ];
           this.length = 2;
         } else {
-          assert2(number < 9007199254740992);
+          assert(number < 9007199254740992);
           this.words = [
             number & 67108863,
             number / 67108864 & 67108863,
@@ -71425,7 +71410,7 @@ var require_bn2 = __commonJS({
         this._initArray(this.toArray(), base, endian);
       };
       BN.prototype._initArray = function _initArray(number, base, endian) {
-        assert2(typeof number.length === "number");
+        assert(typeof number.length === "number");
         if (number.length <= 0) {
           this.words = [0];
           this.length = 1;
@@ -71770,7 +71755,7 @@ var require_bn2 = __commonJS({
           }
           return out;
         }
-        assert2(false, "Base should be between 2 and 36");
+        assert(false, "Base should be between 2 and 36");
       };
       BN.prototype.toNumber = function toNumber() {
         var ret = this.words[0];
@@ -71779,7 +71764,7 @@ var require_bn2 = __commonJS({
         } else if (this.length === 3 && this.words[2] === 1) {
           ret += 4503599627370496 + this.words[1] * 67108864;
         } else if (this.length > 2) {
-          assert2(false, "Number can only safely store up to 53 bits");
+          assert(false, "Number can only safely store up to 53 bits");
         }
         return this.negative !== 0 ? -ret : ret;
       };
@@ -71787,7 +71772,7 @@ var require_bn2 = __commonJS({
         return this.toString(16);
       };
       BN.prototype.toBuffer = function toBuffer(endian, length) {
-        assert2(typeof Buffer2 !== "undefined");
+        assert(typeof Buffer2 !== "undefined");
         return this.toArrayLike(Buffer2, endian, length);
       };
       BN.prototype.toArray = function toArray(endian, length) {
@@ -71796,8 +71781,8 @@ var require_bn2 = __commonJS({
       BN.prototype.toArrayLike = function toArrayLike(ArrayType, endian, length) {
         var byteLength = this.byteLength();
         var reqLength = length || Math.max(1, byteLength);
-        assert2(byteLength <= reqLength, "byte array longer than desired length");
-        assert2(reqLength > 0, "Requested array length <= 0");
+        assert(byteLength <= reqLength, "byte array longer than desired length");
+        assert(reqLength > 0, "Requested array length <= 0");
         this.strip();
         var littleEndian = endian === "le";
         var res = new ArrayType(reqLength);
@@ -71940,7 +71925,7 @@ var require_bn2 = __commonJS({
         return this.strip();
       };
       BN.prototype.ior = function ior(num) {
-        assert2((this.negative | num.negative) === 0);
+        assert((this.negative | num.negative) === 0);
         return this.iuor(num);
       };
       BN.prototype.or = function or(num) {
@@ -71967,7 +71952,7 @@ var require_bn2 = __commonJS({
         return this.strip();
       };
       BN.prototype.iand = function iand(num) {
-        assert2((this.negative | num.negative) === 0);
+        assert((this.negative | num.negative) === 0);
         return this.iuand(num);
       };
       BN.prototype.and = function and(num) {
@@ -72002,7 +71987,7 @@ var require_bn2 = __commonJS({
         return this.strip();
       };
       BN.prototype.ixor = function ixor(num) {
-        assert2((this.negative | num.negative) === 0);
+        assert((this.negative | num.negative) === 0);
         return this.iuxor(num);
       };
       BN.prototype.xor = function xor(num) {
@@ -72016,7 +72001,7 @@ var require_bn2 = __commonJS({
         return num.clone().iuxor(this);
       };
       BN.prototype.inotn = function inotn(width) {
-        assert2(typeof width === "number" && width >= 0);
+        assert(typeof width === "number" && width >= 0);
         var bytesNeeded = Math.ceil(width / 26) | 0;
         var bitsLeft = width % 26;
         this._expand(bytesNeeded);
@@ -72035,7 +72020,7 @@ var require_bn2 = __commonJS({
         return this.clone().inotn(width);
       };
       BN.prototype.setn = function setn(bit, val) {
-        assert2(typeof bit === "number" && bit >= 0);
+        assert(typeof bit === "number" && bit >= 0);
         var off = bit / 26 | 0;
         var wbit = bit % 26;
         this._expand(off + 1);
@@ -72902,8 +72887,8 @@ var require_bn2 = __commonJS({
         for (i = 2 * len; i < N; ++i) {
           rws[i] = 0;
         }
-        assert2(carry === 0);
-        assert2((carry & ~8191) === 0);
+        assert(carry === 0);
+        assert((carry & ~8191) === 0);
       };
       FFTM.prototype.stub = function stub(N) {
         var ph = new Array(N);
@@ -72955,8 +72940,8 @@ var require_bn2 = __commonJS({
         return this.clone().mulTo(num, this);
       };
       BN.prototype.imuln = function imuln(num) {
-        assert2(typeof num === "number");
-        assert2(num < 67108864);
+        assert(typeof num === "number");
+        assert(num < 67108864);
         var carry = 0;
         for (var i = 0; i < this.length; i++) {
           var w = (this.words[i] | 0) * num;
@@ -73000,7 +72985,7 @@ var require_bn2 = __commonJS({
         return res;
       };
       BN.prototype.iushln = function iushln(bits) {
-        assert2(typeof bits === "number" && bits >= 0);
+        assert(typeof bits === "number" && bits >= 0);
         var r = bits % 26;
         var s = (bits - r) / 26;
         var carryMask = 67108863 >>> 26 - r << 26 - r;
@@ -73030,11 +73015,11 @@ var require_bn2 = __commonJS({
         return this.strip();
       };
       BN.prototype.ishln = function ishln(bits) {
-        assert2(this.negative === 0);
+        assert(this.negative === 0);
         return this.iushln(bits);
       };
       BN.prototype.iushrn = function iushrn(bits, hint, extended) {
-        assert2(typeof bits === "number" && bits >= 0);
+        assert(typeof bits === "number" && bits >= 0);
         var h;
         if (hint) {
           h = (hint - hint % 26) / 26;
@@ -73079,7 +73064,7 @@ var require_bn2 = __commonJS({
         return this.strip();
       };
       BN.prototype.ishrn = function ishrn(bits, hint, extended) {
-        assert2(this.negative === 0);
+        assert(this.negative === 0);
         return this.iushrn(bits, hint, extended);
       };
       BN.prototype.shln = function shln(bits) {
@@ -73095,7 +73080,7 @@ var require_bn2 = __commonJS({
         return this.clone().iushrn(bits);
       };
       BN.prototype.testn = function testn(bit) {
-        assert2(typeof bit === "number" && bit >= 0);
+        assert(typeof bit === "number" && bit >= 0);
         var r = bit % 26;
         var s = (bit - r) / 26;
         var q = 1 << r;
@@ -73105,10 +73090,10 @@ var require_bn2 = __commonJS({
         return !!(w & q);
       };
       BN.prototype.imaskn = function imaskn(bits) {
-        assert2(typeof bits === "number" && bits >= 0);
+        assert(typeof bits === "number" && bits >= 0);
         var r = bits % 26;
         var s = (bits - r) / 26;
-        assert2(this.negative === 0, "imaskn works only with positive numbers");
+        assert(this.negative === 0, "imaskn works only with positive numbers");
         if (this.length <= s) {
           return this;
         }
@@ -73126,8 +73111,8 @@ var require_bn2 = __commonJS({
         return this.clone().imaskn(bits);
       };
       BN.prototype.iaddn = function iaddn(num) {
-        assert2(typeof num === "number");
-        assert2(num < 67108864);
+        assert(typeof num === "number");
+        assert(num < 67108864);
         if (num < 0)
           return this.isubn(-num);
         if (this.negative !== 0) {
@@ -73157,8 +73142,8 @@ var require_bn2 = __commonJS({
         return this;
       };
       BN.prototype.isubn = function isubn(num) {
-        assert2(typeof num === "number");
-        assert2(num < 67108864);
+        assert(typeof num === "number");
+        assert(num < 67108864);
         if (num < 0)
           return this.iaddn(-num);
         if (this.negative !== 0) {
@@ -73212,7 +73197,7 @@ var require_bn2 = __commonJS({
         }
         if (carry === 0)
           return this.strip();
-        assert2(carry === -1);
+        assert(carry === -1);
         carry = 0;
         for (i = 0; i < this.length; i++) {
           w = -(this.words[i] | 0) + carry;
@@ -73280,7 +73265,7 @@ var require_bn2 = __commonJS({
         };
       };
       BN.prototype.divmod = function divmod(num, mode, positive) {
-        assert2(!num.isZero());
+        assert(!num.isZero());
         if (this.isZero()) {
           return {
             div: new BN(0),
@@ -73375,7 +73360,7 @@ var require_bn2 = __commonJS({
         return dm.div.negative !== 0 ? dm.div.isubn(1) : dm.div.iaddn(1);
       };
       BN.prototype.modn = function modn(num) {
-        assert2(num <= 67108863);
+        assert(num <= 67108863);
         var p = (1 << 26) % num;
         var acc = 0;
         for (var i = this.length - 1; i >= 0; i--) {
@@ -73384,7 +73369,7 @@ var require_bn2 = __commonJS({
         return acc;
       };
       BN.prototype.idivn = function idivn(num) {
-        assert2(num <= 67108863);
+        assert(num <= 67108863);
         var carry = 0;
         for (var i = this.length - 1; i >= 0; i--) {
           var w = (this.words[i] | 0) + carry * 67108864;
@@ -73397,8 +73382,8 @@ var require_bn2 = __commonJS({
         return this.clone().idivn(num);
       };
       BN.prototype.egcd = function egcd(p) {
-        assert2(p.negative === 0);
-        assert2(!p.isZero());
+        assert(p.negative === 0);
+        assert(!p.isZero());
         var x = this;
         var y = p.clone();
         if (x.negative !== 0) {
@@ -73462,8 +73447,8 @@ var require_bn2 = __commonJS({
         };
       };
       BN.prototype._invmp = function _invmp(p) {
-        assert2(p.negative === 0);
-        assert2(!p.isZero());
+        assert(p.negative === 0);
+        assert(!p.isZero());
         var a = this;
         var b = p.clone();
         if (a.negative !== 0) {
@@ -73561,7 +73546,7 @@ var require_bn2 = __commonJS({
         return this.words[0] & num;
       };
       BN.prototype.bincn = function bincn(bit) {
-        assert2(typeof bit === "number");
+        assert(typeof bit === "number");
         var r = bit % 26;
         var s = (bit - r) / 26;
         var q = 1 << r;
@@ -73601,7 +73586,7 @@ var require_bn2 = __commonJS({
           if (negative) {
             num = -num;
           }
-          assert2(num <= 67108863, "Number is too big");
+          assert(num <= 67108863, "Number is too big");
           var w = this.words[0] | 0;
           res = w === num ? 0 : w < num ? -1 : 1;
         }
@@ -73673,12 +73658,12 @@ var require_bn2 = __commonJS({
         return new Red(num);
       };
       BN.prototype.toRed = function toRed(ctx) {
-        assert2(!this.red, "Already a number in reduction context");
-        assert2(this.negative === 0, "red works only with positives");
+        assert(!this.red, "Already a number in reduction context");
+        assert(this.negative === 0, "red works only with positives");
         return ctx.convertTo(this)._forceRed(ctx);
       };
       BN.prototype.fromRed = function fromRed() {
-        assert2(this.red, "fromRed works only with numbers in reduction context");
+        assert(this.red, "fromRed works only with numbers in reduction context");
         return this.red.convertFrom(this);
       };
       BN.prototype._forceRed = function _forceRed(ctx) {
@@ -73686,66 +73671,66 @@ var require_bn2 = __commonJS({
         return this;
       };
       BN.prototype.forceRed = function forceRed(ctx) {
-        assert2(!this.red, "Already a number in reduction context");
+        assert(!this.red, "Already a number in reduction context");
         return this._forceRed(ctx);
       };
       BN.prototype.redAdd = function redAdd(num) {
-        assert2(this.red, "redAdd works only with red numbers");
+        assert(this.red, "redAdd works only with red numbers");
         return this.red.add(this, num);
       };
       BN.prototype.redIAdd = function redIAdd(num) {
-        assert2(this.red, "redIAdd works only with red numbers");
+        assert(this.red, "redIAdd works only with red numbers");
         return this.red.iadd(this, num);
       };
       BN.prototype.redSub = function redSub(num) {
-        assert2(this.red, "redSub works only with red numbers");
+        assert(this.red, "redSub works only with red numbers");
         return this.red.sub(this, num);
       };
       BN.prototype.redISub = function redISub(num) {
-        assert2(this.red, "redISub works only with red numbers");
+        assert(this.red, "redISub works only with red numbers");
         return this.red.isub(this, num);
       };
       BN.prototype.redShl = function redShl(num) {
-        assert2(this.red, "redShl works only with red numbers");
+        assert(this.red, "redShl works only with red numbers");
         return this.red.shl(this, num);
       };
       BN.prototype.redMul = function redMul(num) {
-        assert2(this.red, "redMul works only with red numbers");
+        assert(this.red, "redMul works only with red numbers");
         this.red._verify2(this, num);
         return this.red.mul(this, num);
       };
       BN.prototype.redIMul = function redIMul(num) {
-        assert2(this.red, "redMul works only with red numbers");
+        assert(this.red, "redMul works only with red numbers");
         this.red._verify2(this, num);
         return this.red.imul(this, num);
       };
       BN.prototype.redSqr = function redSqr() {
-        assert2(this.red, "redSqr works only with red numbers");
+        assert(this.red, "redSqr works only with red numbers");
         this.red._verify1(this);
         return this.red.sqr(this);
       };
       BN.prototype.redISqr = function redISqr() {
-        assert2(this.red, "redISqr works only with red numbers");
+        assert(this.red, "redISqr works only with red numbers");
         this.red._verify1(this);
         return this.red.isqr(this);
       };
       BN.prototype.redSqrt = function redSqrt() {
-        assert2(this.red, "redSqrt works only with red numbers");
+        assert(this.red, "redSqrt works only with red numbers");
         this.red._verify1(this);
         return this.red.sqrt(this);
       };
       BN.prototype.redInvm = function redInvm() {
-        assert2(this.red, "redInvm works only with red numbers");
+        assert(this.red, "redInvm works only with red numbers");
         this.red._verify1(this);
         return this.red.invm(this);
       };
       BN.prototype.redNeg = function redNeg() {
-        assert2(this.red, "redNeg works only with red numbers");
+        assert(this.red, "redNeg works only with red numbers");
         this.red._verify1(this);
         return this.red.neg(this);
       };
       BN.prototype.redPow = function redPow(num) {
-        assert2(this.red && !num.red, "redPow(normalNum)");
+        assert(this.red && !num.red, "redPow(normalNum)");
         this.red._verify1(this);
         return this.red.pow(this, num);
       };
@@ -73913,18 +73898,18 @@ var require_bn2 = __commonJS({
           this.m = prime.p;
           this.prime = prime;
         } else {
-          assert2(m.gtn(1), "modulus must be greater than 1");
+          assert(m.gtn(1), "modulus must be greater than 1");
           this.m = m;
           this.prime = null;
         }
       }
       Red.prototype._verify1 = function _verify1(a) {
-        assert2(a.negative === 0, "red works only with positives");
-        assert2(a.red, "red works only with red numbers");
+        assert(a.negative === 0, "red works only with positives");
+        assert(a.red, "red works only with red numbers");
       };
       Red.prototype._verify2 = function _verify2(a, b) {
-        assert2((a.negative | b.negative) === 0, "red works only with positives");
-        assert2(
+        assert((a.negative | b.negative) === 0, "red works only with positives");
+        assert(
           a.red && a.red === b.red,
           "red works only with red numbers"
         );
@@ -73994,7 +73979,7 @@ var require_bn2 = __commonJS({
         if (a.isZero())
           return a.clone();
         var mod3 = this.m.andln(3);
-        assert2(mod3 % 2 === 1);
+        assert(mod3 % 2 === 1);
         if (mod3 === 3) {
           var pow = this.m.add(new BN(1)).iushrn(2);
           return this.pow(a, pow);
@@ -74005,7 +73990,7 @@ var require_bn2 = __commonJS({
           s++;
           q.iushrn(1);
         }
-        assert2(!q.isZero());
+        assert(!q.isZero());
         var one = new BN(1).toRed(this);
         var nOne = one.redNeg();
         var lpow = this.m.subn(1).iushrn(1);
@@ -74023,7 +74008,7 @@ var require_bn2 = __commonJS({
           for (var i = 0; tmp.cmp(one) !== 0; i++) {
             tmp = tmp.redSqr();
           }
-          assert2(i < m);
+          assert(i < m);
           var b = this.pow(c, new BN(1).iushln(m - i - 1));
           r = r.redMul(b);
           c = b.redSqr();
@@ -74160,12 +74145,12 @@ var require_bn2 = __commonJS({
 // node_modules/minimalistic-assert/index.js
 var require_minimalistic_assert = __commonJS({
   "node_modules/minimalistic-assert/index.js"(exports2, module2) {
-    module2.exports = assert2;
-    function assert2(val, msg) {
+    module2.exports = assert;
+    function assert(val, msg) {
       if (!val)
         throw new Error(msg || "Assertion failed");
     }
-    assert2.equal = function assertEqual(l, r, msg) {
+    assert.equal = function assertEqual(l, r, msg) {
       if (l != r)
         throw new Error(msg || "Assertion failed: " + l + " != " + r);
     };
@@ -74399,7 +74384,7 @@ var require_base = __commonJS({
     var utils = require_utils9();
     var getNAF = utils.getNAF;
     var getJSF = utils.getJSF;
-    var assert2 = utils.assert;
+    var assert = utils.assert;
     function BaseCurve(type, conf) {
       this.type = type;
       this.p = new BN(conf.p, 16);
@@ -74430,7 +74415,7 @@ var require_base = __commonJS({
       throw new Error("Not implemented");
     };
     BaseCurve.prototype._fixedNafMul = function _fixedNafMul(p, k) {
-      assert2(p.precomputed);
+      assert(p.precomputed);
       var doubles = p._getDoubles();
       var naf = getNAF(k, 1, this._bitLength);
       var I = (1 << doubles.step + 1) - (doubles.step % 2 === 0 ? 2 : 1);
@@ -74474,7 +74459,7 @@ var require_base = __commonJS({
         if (i < 0)
           break;
         var z = naf[i];
-        assert2(z !== 0);
+        assert(z !== 0);
         if (p.type === "affine") {
           if (z > 0)
             acc = acc.mixedAdd(wnd[z - 1 >> 1]);
@@ -74625,9 +74610,9 @@ var require_base = __commonJS({
       var len = this.p.byteLength();
       if ((bytes[0] === 4 || bytes[0] === 6 || bytes[0] === 7) && bytes.length - 1 === 2 * len) {
         if (bytes[0] === 6)
-          assert2(bytes[bytes.length - 1] % 2 === 0);
+          assert(bytes[bytes.length - 1] % 2 === 0);
         else if (bytes[0] === 7)
-          assert2(bytes[bytes.length - 1] % 2 === 1);
+          assert(bytes[bytes.length - 1] % 2 === 1);
         var res = this.point(
           bytes.slice(1, 1 + len),
           bytes.slice(1 + len, 1 + 2 * len)
@@ -74721,7 +74706,7 @@ var require_short = __commonJS({
     var BN = require_bn2();
     var inherits = require_inherits();
     var Base = require_base();
-    var assert2 = utils.assert;
+    var assert = utils.assert;
     function ShortCurve(conf) {
       Base.call(this, "short", conf);
       this.a = new BN(conf.a, 16).toRed(this.red);
@@ -74755,7 +74740,7 @@ var require_short = __commonJS({
           lambda = lambdas[0];
         } else {
           lambda = lambdas[1];
-          assert2(this.g.mul(lambda).x.cmp(this.g.x.redMul(beta)) === 0);
+          assert(this.g.mul(lambda).x.cmp(this.g.x.redMul(beta)) === 0);
         }
       }
       var basis;
@@ -75547,7 +75532,7 @@ var require_edwards = __commonJS({
     var BN = require_bn2();
     var inherits = require_inherits();
     var Base = require_base();
-    var assert2 = utils.assert;
+    var assert = utils.assert;
     function EdwardsCurve(conf) {
       this.twisted = (conf.a | 0) !== 1;
       this.mOneA = this.twisted && (conf.a | 0) === -1;
@@ -75559,7 +75544,7 @@ var require_edwards = __commonJS({
       this.c2 = this.c.redSqr();
       this.d = new BN(conf.d, 16).toRed(this.red);
       this.dd = this.d.redAdd(this.d);
-      assert2(!this.twisted || this.c.fromRed().cmpn(1) === 0);
+      assert(!this.twisted || this.c.fromRed().cmpn(1) === 0);
       this.oneC = (conf.c | 0) === 1;
     }
     inherits(EdwardsCurve, Base);
@@ -75856,7 +75841,7 @@ var require_curve = __commonJS({
 var require_utils10 = __commonJS({
   "node_modules/hash.js/lib/hash/utils.js"(exports2) {
     "use strict";
-    var assert2 = require_minimalistic_assert();
+    var assert = require_minimalistic_assert();
     var inherits = require_inherits();
     exports2.inherits = inherits;
     function isSurrogatePair(msg, i) {
@@ -75961,7 +75946,7 @@ var require_utils10 = __commonJS({
     exports2.zero8 = zero8;
     function join32(msg, start, end, endian) {
       var len = end - start;
-      assert2(len % 4 === 0);
+      assert(len % 4 === 0);
       var res = new Array(len / 4);
       for (var i = 0, k = start; i < res.length; i++, k += 4) {
         var w;
@@ -76102,7 +76087,7 @@ var require_common3 = __commonJS({
   "node_modules/hash.js/lib/hash/common.js"(exports2) {
     "use strict";
     var utils = require_utils10();
-    var assert2 = require_minimalistic_assert();
+    var assert = require_minimalistic_assert();
     function BlockHash() {
       this.pending = null;
       this.pendingTotal = 0;
@@ -76136,7 +76121,7 @@ var require_common3 = __commonJS({
     };
     BlockHash.prototype.digest = function digest(enc) {
       this.update(this._pad());
-      assert2(this.pending === null);
+      assert(this.pending === null);
       return this._digest(enc);
     };
     BlockHash.prototype._pad = function pad() {
@@ -76301,7 +76286,7 @@ var require__2 = __commonJS({
     var utils = require_utils10();
     var common = require_common3();
     var shaCommon = require_common4();
-    var assert2 = require_minimalistic_assert();
+    var assert = require_minimalistic_assert();
     var sum32 = utils.sum32;
     var sum32_4 = utils.sum32_4;
     var sum32_5 = utils.sum32_5;
@@ -76415,7 +76400,7 @@ var require__2 = __commonJS({
       var f = this.h[5];
       var g = this.h[6];
       var h = this.h[7];
-      assert2(this.k.length === W.length);
+      assert(this.k.length === W.length);
       for (i = 0; i < W.length; i++) {
         var T1 = sum32_5(h, s1_256(e), ch32(e, f, g), this.k[i], W[i]);
         var T2 = sum32(s0_256(a), maj32(a, b, c));
@@ -76488,7 +76473,7 @@ var require__4 = __commonJS({
     "use strict";
     var utils = require_utils10();
     var common = require_common3();
-    var assert2 = require_minimalistic_assert();
+    var assert = require_minimalistic_assert();
     var rotr64_hi = utils.rotr64_hi;
     var rotr64_lo = utils.rotr64_lo;
     var shr64_hi = utils.shr64_hi;
@@ -76748,7 +76733,7 @@ var require__4 = __commonJS({
       var gl = this.h[13];
       var hh = this.h[14];
       var hl = this.h[15];
-      assert2(this.k.length === W.length);
+      assert(this.k.length === W.length);
       for (var i = 0; i < W.length; i += 2) {
         var c0_hi = hh;
         var c0_lo = hl;
@@ -77423,7 +77408,7 @@ var require_hmac3 = __commonJS({
   "node_modules/hash.js/lib/hash/hmac.js"(exports2, module2) {
     "use strict";
     var utils = require_utils10();
-    var assert2 = require_minimalistic_assert();
+    var assert = require_minimalistic_assert();
     function Hmac(hash, key, enc) {
       if (!(this instanceof Hmac))
         return new Hmac(hash, key, enc);
@@ -77438,7 +77423,7 @@ var require_hmac3 = __commonJS({
     Hmac.prototype._init = function init(key) {
       if (key.length > this.blockSize)
         key = new this.Hash().update(key).digest();
-      assert2(key.length <= this.blockSize);
+      assert(key.length <= this.blockSize);
       for (var i = key.length; i < this.blockSize; i++)
         key.push(0);
       for (i = 0; i < key.length; i++)
@@ -78271,7 +78256,7 @@ var require_curves = __commonJS({
     var hash = require_hash2();
     var curve = require_curve();
     var utils = require_utils9();
-    var assert2 = utils.assert;
+    var assert = utils.assert;
     function PresetCurve(options) {
       if (options.type === "short")
         this.curve = new curve.short(options);
@@ -78282,8 +78267,8 @@ var require_curves = __commonJS({
       this.g = this.curve.g;
       this.n = this.curve.n;
       this.hash = options.hash;
-      assert2(this.g.validate(), "Invalid curve");
-      assert2(this.g.mul(this.n).isInfinity(), "Invalid curve, G*N != O");
+      assert(this.g.validate(), "Invalid curve");
+      assert(this.g.mul(this.n).isInfinity(), "Invalid curve, G*N != O");
     }
     curves.PresetCurve = PresetCurve;
     function defineCurve(name, options) {
@@ -78445,7 +78430,7 @@ var require_hmac_drbg = __commonJS({
     "use strict";
     var hash = require_hash2();
     var utils = require_utils8();
-    var assert2 = require_minimalistic_assert();
+    var assert = require_minimalistic_assert();
     function HmacDRBG(options) {
       if (!(this instanceof HmacDRBG))
         return new HmacDRBG(options);
@@ -78460,7 +78445,7 @@ var require_hmac_drbg = __commonJS({
       var entropy = utils.toArray(options.entropy, options.entropyEnc || "hex");
       var nonce = utils.toArray(options.nonce, options.nonceEnc || "hex");
       var pers = utils.toArray(options.pers, options.persEnc || "hex");
-      assert2(
+      assert(
         entropy.length >= this.minEntropy / 8,
         "Not enough entropy. Minimum is: " + this.minEntropy + " bits"
       );
@@ -78501,7 +78486,7 @@ var require_hmac_drbg = __commonJS({
       }
       entropy = utils.toArray(entropy, entropyEnc);
       add = utils.toArray(add, addEnc);
-      assert2(
+      assert(
         entropy.length >= this.minEntropy / 8,
         "Not enough entropy. Minimum is: " + this.minEntropy + " bits"
       );
@@ -78539,7 +78524,7 @@ var require_key = __commonJS({
     "use strict";
     var BN = require_bn2();
     var utils = require_utils9();
-    var assert2 = utils.assert;
+    var assert = utils.assert;
     function KeyPair(ec, options) {
       this.ec = ec;
       this.priv = null;
@@ -78600,9 +78585,9 @@ var require_key = __commonJS({
     KeyPair.prototype._importPublic = function _importPublic(key, enc) {
       if (key.x || key.y) {
         if (this.ec.curve.type === "mont") {
-          assert2(key.x, "Need x coordinate");
+          assert(key.x, "Need x coordinate");
         } else if (this.ec.curve.type === "short" || this.ec.curve.type === "edwards") {
-          assert2(key.x && key.y, "Need both x and y coordinate");
+          assert(key.x && key.y, "Need both x and y coordinate");
         }
         this.pub = this.ec.curve.point(key.x, key.y);
         return;
@@ -78611,7 +78596,7 @@ var require_key = __commonJS({
     };
     KeyPair.prototype.derive = function derive(pub) {
       if (!pub.validate()) {
-        assert2(pub.validate(), "public point not validated");
+        assert(pub.validate(), "public point not validated");
       }
       return pub.mul(this.priv).getX();
     };
@@ -78633,13 +78618,13 @@ var require_signature3 = __commonJS({
     "use strict";
     var BN = require_bn2();
     var utils = require_utils9();
-    var assert2 = utils.assert;
+    var assert = utils.assert;
     function Signature(options, enc) {
       if (options instanceof Signature)
         return options;
       if (this._importDER(options, enc))
         return;
-      assert2(options.r && options.s, "Signature without r or s");
+      assert(options.r && options.s, "Signature without r or s");
       this.r = new BN(options.r, 16);
       this.s = new BN(options.s, 16);
       if (options.recoveryParam === void 0)
@@ -78782,14 +78767,14 @@ var require_ec = __commonJS({
     var utils = require_utils9();
     var curves = require_curves();
     var rand = require_brorand();
-    var assert2 = utils.assert;
+    var assert = utils.assert;
     var KeyPair = require_key();
     var Signature = require_signature3();
     function EC(options) {
       if (!(this instanceof EC))
         return new EC(options);
       if (typeof options === "string") {
-        assert2(
+        assert(
           Object.prototype.hasOwnProperty.call(curves, options),
           "Unknown curve " + options
         );
@@ -78915,7 +78900,7 @@ var require_ec = __commonJS({
       return p.eqXToP(r);
     };
     EC.prototype.recoverPubKey = function(msg, signature, j, enc) {
-      assert2((3 & j) === j, "The recovery param is more than two bits");
+      assert((3 & j) === j, "The recovery param is more than two bits");
       signature = new Signature(signature, enc);
       var n = this.n;
       var e = new BN(msg);
@@ -78958,7 +78943,7 @@ var require_key2 = __commonJS({
   "node_modules/elliptic/lib/elliptic/eddsa/key.js"(exports2, module2) {
     "use strict";
     var utils = require_utils9();
-    var assert2 = utils.assert;
+    var assert = utils.assert;
     var parseBytes = utils.parseBytes;
     var cachedProperty = utils.cachedProperty;
     function KeyPair(eddsa, params) {
@@ -79010,14 +78995,14 @@ var require_key2 = __commonJS({
       return this.hash().slice(this.eddsa.encodingLength);
     });
     KeyPair.prototype.sign = function sign(message) {
-      assert2(this._secret, "KeyPair can only verify");
+      assert(this._secret, "KeyPair can only verify");
       return this.eddsa.sign(message, this);
     };
     KeyPair.prototype.verify = function verify(message, sig) {
       return this.eddsa.verify(message, sig, this);
     };
     KeyPair.prototype.getSecret = function getSecret(enc) {
-      assert2(this._secret, "KeyPair is public only");
+      assert(this._secret, "KeyPair is public only");
       return utils.encode(this.secret(), enc);
     };
     KeyPair.prototype.getPublic = function getPublic(enc) {
@@ -79033,7 +79018,7 @@ var require_signature4 = __commonJS({
     "use strict";
     var BN = require_bn2();
     var utils = require_utils9();
-    var assert2 = utils.assert;
+    var assert = utils.assert;
     var cachedProperty = utils.cachedProperty;
     var parseBytes = utils.parseBytes;
     function Signature(eddsa, sig) {
@@ -79046,7 +79031,7 @@ var require_signature4 = __commonJS({
           S: sig.slice(eddsa.encodingLength)
         };
       }
-      assert2(sig.R && sig.S, "Signature without R or S");
+      assert(sig.R && sig.S, "Signature without R or S");
       if (eddsa.isPoint(sig.R))
         this._R = sig.R;
       if (sig.S instanceof BN)
@@ -79083,12 +79068,12 @@ var require_eddsa = __commonJS({
     var hash = require_hash2();
     var curves = require_curves();
     var utils = require_utils9();
-    var assert2 = utils.assert;
+    var assert = utils.assert;
     var parseBytes = utils.parseBytes;
     var KeyPair = require_key2();
     var Signature = require_signature4();
     function EDDSA(curve) {
-      assert2(curve === "ed25519", "only tested with ed25519 so far");
+      assert(curve === "ed25519", "only tested with ed25519 so far");
       if (!(this instanceof EDDSA))
         return new EDDSA(curve);
       curve = curves[curve].curve;
@@ -100168,25 +100153,25 @@ var require_lib41 = __commonJS({
       RECOVER: "Public key could not be recover",
       ECDH: "Scalar was invalid (zero or overflow)"
     };
-    function assert2(cond, msg) {
+    function assert(cond, msg) {
       if (!cond)
         throw new Error(msg);
     }
     function isUint8Array(name, value, length) {
-      assert2(value instanceof Uint8Array, `Expected ${name} to be an Uint8Array`);
+      assert(value instanceof Uint8Array, `Expected ${name} to be an Uint8Array`);
       if (length !== void 0) {
         if (Array.isArray(length)) {
           const numbers = length.join(", ");
           const msg = `Expected ${name} to be an Uint8Array with length [${numbers}]`;
-          assert2(length.includes(value.length), msg);
+          assert(length.includes(value.length), msg);
         } else {
           const msg = `Expected ${name} to be an Uint8Array with length ${length}`;
-          assert2(value.length === length, msg);
+          assert(value.length === length, msg);
         }
       }
     }
     function isCompressed(value) {
-      assert2(toTypeString(value) === "Boolean", "Expected compressed to be a Boolean");
+      assert(toTypeString(value) === "Boolean", "Expected compressed to be a Boolean");
     }
     function getAssertedOutput(output = (len) => new Uint8Array(len), length) {
       if (typeof output === "function")
@@ -100200,7 +100185,7 @@ var require_lib41 = __commonJS({
     module2.exports = (secp256k1) => {
       return {
         contextRandomize(seed) {
-          assert2(
+          assert(
             seed === null || seed instanceof Uint8Array,
             "Expected seed to be an Uint8Array or null"
           );
@@ -100290,8 +100275,8 @@ var require_lib41 = __commonJS({
           }
         },
         publicKeyCombine(pubkeys, compressed = true, output) {
-          assert2(Array.isArray(pubkeys), "Expected public keys to be an Array");
-          assert2(pubkeys.length > 0, "Expected public keys array will have more than zero items");
+          assert(Array.isArray(pubkeys), "Expected public keys to be an Array");
+          assert(pubkeys.length > 0, "Expected public keys array will have more than zero items");
           for (const pubkey of pubkeys) {
             isUint8Array("public key", pubkey, [33, 65]);
           }
@@ -100373,11 +100358,11 @@ var require_lib41 = __commonJS({
         ecdsaSign(msg32, seckey, options = {}, output) {
           isUint8Array("message", msg32, 32);
           isUint8Array("private key", seckey, 32);
-          assert2(toTypeString(options) === "Object", "Expected options to be an Object");
+          assert(toTypeString(options) === "Object", "Expected options to be an Object");
           if (options.data !== void 0)
             isUint8Array("options.data", options.data);
           if (options.noncefn !== void 0)
-            assert2(toTypeString(options.noncefn) === "Function", "Expected options.noncefn to be a Function");
+            assert(toTypeString(options.noncefn) === "Function", "Expected options.noncefn to be a Function");
           output = getAssertedOutput(output, 64);
           const obj = { signature: output, recid: null };
           switch (secp256k1.ecdsaSign(obj, msg32, seckey, options.data, options.noncefn)) {
@@ -100406,7 +100391,7 @@ var require_lib41 = __commonJS({
         },
         ecdsaRecover(sig, recid, msg32, compressed = true, output) {
           isUint8Array("signature", sig, 64);
-          assert2(
+          assert(
             toTypeString(recid) === "Number" && recid >= 0 && recid <= 3,
             "Expected recovery id to be a Number within interval [0, 3]"
           );
@@ -100427,11 +100412,11 @@ var require_lib41 = __commonJS({
         ecdh(pubkey, seckey, options = {}, output) {
           isUint8Array("public key", pubkey, [33, 65]);
           isUint8Array("private key", seckey, 32);
-          assert2(toTypeString(options) === "Object", "Expected options to be an Object");
+          assert(toTypeString(options) === "Object", "Expected options to be an Object");
           if (options.data !== void 0)
             isUint8Array("options.data", options.data);
           if (options.hashfn !== void 0) {
-            assert2(toTypeString(options.hashfn) === "Function", "Expected options.hashfn to be a Function");
+            assert(toTypeString(options.hashfn) === "Function", "Expected options.hashfn to be a Function");
             if (options.xbuf !== void 0)
               isUint8Array("options.xbuf", options.xbuf, 32);
             if (options.ybuf !== void 0)
@@ -124568,7 +124553,7 @@ var require_bn3 = __commonJS({
   "node_modules/ethjs-unit/node_modules/bn.js/lib/bn.js"(exports2, module2) {
     (function(module3, exports3) {
       "use strict";
-      function assert2(val, msg) {
+      function assert(val, msg) {
         if (!val)
           throw new Error(msg || "Assertion failed");
       }
@@ -124634,7 +124619,7 @@ var require_bn3 = __commonJS({
         if (base === "hex") {
           base = 16;
         }
-        assert2(base === (base | 0) && base >= 2 && base <= 36);
+        assert(base === (base | 0) && base >= 2 && base <= 36);
         number = number.toString().replace(/\s+/g, "");
         var start = 0;
         if (number[0] === "-") {
@@ -124668,7 +124653,7 @@ var require_bn3 = __commonJS({
           ];
           this.length = 2;
         } else {
-          assert2(number < 9007199254740992);
+          assert(number < 9007199254740992);
           this.words = [
             number & 67108863,
             number / 67108864 & 67108863,
@@ -124681,7 +124666,7 @@ var require_bn3 = __commonJS({
         this._initArray(this.toArray(), base, endian);
       };
       BN.prototype._initArray = function _initArray(number, base, endian) {
-        assert2(typeof number.length === "number");
+        assert(typeof number.length === "number");
         if (number.length <= 0) {
           this.words = [0];
           this.length = 1;
@@ -125012,7 +124997,7 @@ var require_bn3 = __commonJS({
           }
           return out;
         }
-        assert2(false, "Base should be between 2 and 36");
+        assert(false, "Base should be between 2 and 36");
       };
       BN.prototype.toNumber = function toNumber() {
         var ret = this.words[0];
@@ -125021,7 +125006,7 @@ var require_bn3 = __commonJS({
         } else if (this.length === 3 && this.words[2] === 1) {
           ret += 4503599627370496 + this.words[1] * 67108864;
         } else if (this.length > 2) {
-          assert2(false, "Number can only safely store up to 53 bits");
+          assert(false, "Number can only safely store up to 53 bits");
         }
         return this.negative !== 0 ? -ret : ret;
       };
@@ -125029,7 +125014,7 @@ var require_bn3 = __commonJS({
         return this.toString(16);
       };
       BN.prototype.toBuffer = function toBuffer(endian, length) {
-        assert2(typeof Buffer2 !== "undefined");
+        assert(typeof Buffer2 !== "undefined");
         return this.toArrayLike(Buffer2, endian, length);
       };
       BN.prototype.toArray = function toArray(endian, length) {
@@ -125038,8 +125023,8 @@ var require_bn3 = __commonJS({
       BN.prototype.toArrayLike = function toArrayLike(ArrayType, endian, length) {
         var byteLength = this.byteLength();
         var reqLength = length || Math.max(1, byteLength);
-        assert2(byteLength <= reqLength, "byte array longer than desired length");
-        assert2(reqLength > 0, "Requested array length <= 0");
+        assert(byteLength <= reqLength, "byte array longer than desired length");
+        assert(reqLength > 0, "Requested array length <= 0");
         this.strip();
         var littleEndian = endian === "le";
         var res = new ArrayType(reqLength);
@@ -125182,7 +125167,7 @@ var require_bn3 = __commonJS({
         return this.strip();
       };
       BN.prototype.ior = function ior(num) {
-        assert2((this.negative | num.negative) === 0);
+        assert((this.negative | num.negative) === 0);
         return this.iuor(num);
       };
       BN.prototype.or = function or(num) {
@@ -125209,7 +125194,7 @@ var require_bn3 = __commonJS({
         return this.strip();
       };
       BN.prototype.iand = function iand(num) {
-        assert2((this.negative | num.negative) === 0);
+        assert((this.negative | num.negative) === 0);
         return this.iuand(num);
       };
       BN.prototype.and = function and(num) {
@@ -125244,7 +125229,7 @@ var require_bn3 = __commonJS({
         return this.strip();
       };
       BN.prototype.ixor = function ixor(num) {
-        assert2((this.negative | num.negative) === 0);
+        assert((this.negative | num.negative) === 0);
         return this.iuxor(num);
       };
       BN.prototype.xor = function xor(num) {
@@ -125258,7 +125243,7 @@ var require_bn3 = __commonJS({
         return num.clone().iuxor(this);
       };
       BN.prototype.inotn = function inotn(width) {
-        assert2(typeof width === "number" && width >= 0);
+        assert(typeof width === "number" && width >= 0);
         var bytesNeeded = Math.ceil(width / 26) | 0;
         var bitsLeft = width % 26;
         this._expand(bytesNeeded);
@@ -125277,7 +125262,7 @@ var require_bn3 = __commonJS({
         return this.clone().inotn(width);
       };
       BN.prototype.setn = function setn(bit, val) {
-        assert2(typeof bit === "number" && bit >= 0);
+        assert(typeof bit === "number" && bit >= 0);
         var off = bit / 26 | 0;
         var wbit = bit % 26;
         this._expand(off + 1);
@@ -126144,8 +126129,8 @@ var require_bn3 = __commonJS({
         for (i = 2 * len; i < N; ++i) {
           rws[i] = 0;
         }
-        assert2(carry === 0);
-        assert2((carry & ~8191) === 0);
+        assert(carry === 0);
+        assert((carry & ~8191) === 0);
       };
       FFTM.prototype.stub = function stub(N) {
         var ph = new Array(N);
@@ -126197,8 +126182,8 @@ var require_bn3 = __commonJS({
         return this.clone().mulTo(num, this);
       };
       BN.prototype.imuln = function imuln(num) {
-        assert2(typeof num === "number");
-        assert2(num < 67108864);
+        assert(typeof num === "number");
+        assert(num < 67108864);
         var carry = 0;
         for (var i = 0; i < this.length; i++) {
           var w = (this.words[i] | 0) * num;
@@ -126242,7 +126227,7 @@ var require_bn3 = __commonJS({
         return res;
       };
       BN.prototype.iushln = function iushln(bits) {
-        assert2(typeof bits === "number" && bits >= 0);
+        assert(typeof bits === "number" && bits >= 0);
         var r = bits % 26;
         var s = (bits - r) / 26;
         var carryMask = 67108863 >>> 26 - r << 26 - r;
@@ -126272,11 +126257,11 @@ var require_bn3 = __commonJS({
         return this.strip();
       };
       BN.prototype.ishln = function ishln(bits) {
-        assert2(this.negative === 0);
+        assert(this.negative === 0);
         return this.iushln(bits);
       };
       BN.prototype.iushrn = function iushrn(bits, hint, extended) {
-        assert2(typeof bits === "number" && bits >= 0);
+        assert(typeof bits === "number" && bits >= 0);
         var h;
         if (hint) {
           h = (hint - hint % 26) / 26;
@@ -126321,7 +126306,7 @@ var require_bn3 = __commonJS({
         return this.strip();
       };
       BN.prototype.ishrn = function ishrn(bits, hint, extended) {
-        assert2(this.negative === 0);
+        assert(this.negative === 0);
         return this.iushrn(bits, hint, extended);
       };
       BN.prototype.shln = function shln(bits) {
@@ -126337,7 +126322,7 @@ var require_bn3 = __commonJS({
         return this.clone().iushrn(bits);
       };
       BN.prototype.testn = function testn(bit) {
-        assert2(typeof bit === "number" && bit >= 0);
+        assert(typeof bit === "number" && bit >= 0);
         var r = bit % 26;
         var s = (bit - r) / 26;
         var q = 1 << r;
@@ -126347,10 +126332,10 @@ var require_bn3 = __commonJS({
         return !!(w & q);
       };
       BN.prototype.imaskn = function imaskn(bits) {
-        assert2(typeof bits === "number" && bits >= 0);
+        assert(typeof bits === "number" && bits >= 0);
         var r = bits % 26;
         var s = (bits - r) / 26;
-        assert2(this.negative === 0, "imaskn works only with positive numbers");
+        assert(this.negative === 0, "imaskn works only with positive numbers");
         if (this.length <= s) {
           return this;
         }
@@ -126368,8 +126353,8 @@ var require_bn3 = __commonJS({
         return this.clone().imaskn(bits);
       };
       BN.prototype.iaddn = function iaddn(num) {
-        assert2(typeof num === "number");
-        assert2(num < 67108864);
+        assert(typeof num === "number");
+        assert(num < 67108864);
         if (num < 0)
           return this.isubn(-num);
         if (this.negative !== 0) {
@@ -126399,8 +126384,8 @@ var require_bn3 = __commonJS({
         return this;
       };
       BN.prototype.isubn = function isubn(num) {
-        assert2(typeof num === "number");
-        assert2(num < 67108864);
+        assert(typeof num === "number");
+        assert(num < 67108864);
         if (num < 0)
           return this.iaddn(-num);
         if (this.negative !== 0) {
@@ -126454,7 +126439,7 @@ var require_bn3 = __commonJS({
         }
         if (carry === 0)
           return this.strip();
-        assert2(carry === -1);
+        assert(carry === -1);
         carry = 0;
         for (i = 0; i < this.length; i++) {
           w = -(this.words[i] | 0) + carry;
@@ -126522,7 +126507,7 @@ var require_bn3 = __commonJS({
         };
       };
       BN.prototype.divmod = function divmod(num, mode, positive) {
-        assert2(!num.isZero());
+        assert(!num.isZero());
         if (this.isZero()) {
           return {
             div: new BN(0),
@@ -126617,7 +126602,7 @@ var require_bn3 = __commonJS({
         return dm.div.negative !== 0 ? dm.div.isubn(1) : dm.div.iaddn(1);
       };
       BN.prototype.modn = function modn(num) {
-        assert2(num <= 67108863);
+        assert(num <= 67108863);
         var p = (1 << 26) % num;
         var acc = 0;
         for (var i = this.length - 1; i >= 0; i--) {
@@ -126626,7 +126611,7 @@ var require_bn3 = __commonJS({
         return acc;
       };
       BN.prototype.idivn = function idivn(num) {
-        assert2(num <= 67108863);
+        assert(num <= 67108863);
         var carry = 0;
         for (var i = this.length - 1; i >= 0; i--) {
           var w = (this.words[i] | 0) + carry * 67108864;
@@ -126639,8 +126624,8 @@ var require_bn3 = __commonJS({
         return this.clone().idivn(num);
       };
       BN.prototype.egcd = function egcd(p) {
-        assert2(p.negative === 0);
-        assert2(!p.isZero());
+        assert(p.negative === 0);
+        assert(!p.isZero());
         var x = this;
         var y = p.clone();
         if (x.negative !== 0) {
@@ -126704,8 +126689,8 @@ var require_bn3 = __commonJS({
         };
       };
       BN.prototype._invmp = function _invmp(p) {
-        assert2(p.negative === 0);
-        assert2(!p.isZero());
+        assert(p.negative === 0);
+        assert(!p.isZero());
         var a = this;
         var b = p.clone();
         if (a.negative !== 0) {
@@ -126803,7 +126788,7 @@ var require_bn3 = __commonJS({
         return this.words[0] & num;
       };
       BN.prototype.bincn = function bincn(bit) {
-        assert2(typeof bit === "number");
+        assert(typeof bit === "number");
         var r = bit % 26;
         var s = (bit - r) / 26;
         var q = 1 << r;
@@ -126843,7 +126828,7 @@ var require_bn3 = __commonJS({
           if (negative) {
             num = -num;
           }
-          assert2(num <= 67108863, "Number is too big");
+          assert(num <= 67108863, "Number is too big");
           var w = this.words[0] | 0;
           res = w === num ? 0 : w < num ? -1 : 1;
         }
@@ -126915,12 +126900,12 @@ var require_bn3 = __commonJS({
         return new Red(num);
       };
       BN.prototype.toRed = function toRed(ctx) {
-        assert2(!this.red, "Already a number in reduction context");
-        assert2(this.negative === 0, "red works only with positives");
+        assert(!this.red, "Already a number in reduction context");
+        assert(this.negative === 0, "red works only with positives");
         return ctx.convertTo(this)._forceRed(ctx);
       };
       BN.prototype.fromRed = function fromRed() {
-        assert2(this.red, "fromRed works only with numbers in reduction context");
+        assert(this.red, "fromRed works only with numbers in reduction context");
         return this.red.convertFrom(this);
       };
       BN.prototype._forceRed = function _forceRed(ctx) {
@@ -126928,66 +126913,66 @@ var require_bn3 = __commonJS({
         return this;
       };
       BN.prototype.forceRed = function forceRed(ctx) {
-        assert2(!this.red, "Already a number in reduction context");
+        assert(!this.red, "Already a number in reduction context");
         return this._forceRed(ctx);
       };
       BN.prototype.redAdd = function redAdd(num) {
-        assert2(this.red, "redAdd works only with red numbers");
+        assert(this.red, "redAdd works only with red numbers");
         return this.red.add(this, num);
       };
       BN.prototype.redIAdd = function redIAdd(num) {
-        assert2(this.red, "redIAdd works only with red numbers");
+        assert(this.red, "redIAdd works only with red numbers");
         return this.red.iadd(this, num);
       };
       BN.prototype.redSub = function redSub(num) {
-        assert2(this.red, "redSub works only with red numbers");
+        assert(this.red, "redSub works only with red numbers");
         return this.red.sub(this, num);
       };
       BN.prototype.redISub = function redISub(num) {
-        assert2(this.red, "redISub works only with red numbers");
+        assert(this.red, "redISub works only with red numbers");
         return this.red.isub(this, num);
       };
       BN.prototype.redShl = function redShl(num) {
-        assert2(this.red, "redShl works only with red numbers");
+        assert(this.red, "redShl works only with red numbers");
         return this.red.shl(this, num);
       };
       BN.prototype.redMul = function redMul(num) {
-        assert2(this.red, "redMul works only with red numbers");
+        assert(this.red, "redMul works only with red numbers");
         this.red._verify2(this, num);
         return this.red.mul(this, num);
       };
       BN.prototype.redIMul = function redIMul(num) {
-        assert2(this.red, "redMul works only with red numbers");
+        assert(this.red, "redMul works only with red numbers");
         this.red._verify2(this, num);
         return this.red.imul(this, num);
       };
       BN.prototype.redSqr = function redSqr() {
-        assert2(this.red, "redSqr works only with red numbers");
+        assert(this.red, "redSqr works only with red numbers");
         this.red._verify1(this);
         return this.red.sqr(this);
       };
       BN.prototype.redISqr = function redISqr() {
-        assert2(this.red, "redISqr works only with red numbers");
+        assert(this.red, "redISqr works only with red numbers");
         this.red._verify1(this);
         return this.red.isqr(this);
       };
       BN.prototype.redSqrt = function redSqrt() {
-        assert2(this.red, "redSqrt works only with red numbers");
+        assert(this.red, "redSqrt works only with red numbers");
         this.red._verify1(this);
         return this.red.sqrt(this);
       };
       BN.prototype.redInvm = function redInvm() {
-        assert2(this.red, "redInvm works only with red numbers");
+        assert(this.red, "redInvm works only with red numbers");
         this.red._verify1(this);
         return this.red.invm(this);
       };
       BN.prototype.redNeg = function redNeg() {
-        assert2(this.red, "redNeg works only with red numbers");
+        assert(this.red, "redNeg works only with red numbers");
         this.red._verify1(this);
         return this.red.neg(this);
       };
       BN.prototype.redPow = function redPow(num) {
-        assert2(this.red && !num.red, "redPow(normalNum)");
+        assert(this.red && !num.red, "redPow(normalNum)");
         this.red._verify1(this);
         return this.red.pow(this, num);
       };
@@ -127151,18 +127136,18 @@ var require_bn3 = __commonJS({
           this.m = prime.p;
           this.prime = prime;
         } else {
-          assert2(m.gtn(1), "modulus must be greater than 1");
+          assert(m.gtn(1), "modulus must be greater than 1");
           this.m = m;
           this.prime = null;
         }
       }
       Red.prototype._verify1 = function _verify1(a) {
-        assert2(a.negative === 0, "red works only with positives");
-        assert2(a.red, "red works only with red numbers");
+        assert(a.negative === 0, "red works only with positives");
+        assert(a.red, "red works only with red numbers");
       };
       Red.prototype._verify2 = function _verify2(a, b) {
-        assert2((a.negative | b.negative) === 0, "red works only with positives");
-        assert2(
+        assert((a.negative | b.negative) === 0, "red works only with positives");
+        assert(
           a.red && a.red === b.red,
           "red works only with red numbers"
         );
@@ -127232,7 +127217,7 @@ var require_bn3 = __commonJS({
         if (a.isZero())
           return a.clone();
         var mod3 = this.m.andln(3);
-        assert2(mod3 % 2 === 1);
+        assert(mod3 % 2 === 1);
         if (mod3 === 3) {
           var pow = this.m.add(new BN(1)).iushrn(2);
           return this.pow(a, pow);
@@ -127243,7 +127228,7 @@ var require_bn3 = __commonJS({
           s++;
           q.iushrn(1);
         }
-        assert2(!q.isZero());
+        assert(!q.isZero());
         var one = new BN(1).toRed(this);
         var nOne = one.redNeg();
         var lpow = this.m.subn(1).iushrn(1);
@@ -127261,7 +127246,7 @@ var require_bn3 = __commonJS({
           for (var i = 0; tmp.cmp(one) !== 0; i++) {
             tmp = tmp.redSqr();
           }
-          assert2(i < m);
+          assert(i < m);
           var b = this.pow(c, new BN(1).iushln(m - i - 1));
           r = r.redMul(b);
           c = b.redSqr();
@@ -127400,7 +127385,7 @@ var require_bn4 = __commonJS({
   "node_modules/number-to-bn/node_modules/bn.js/lib/bn.js"(exports2, module2) {
     (function(module3, exports3) {
       "use strict";
-      function assert2(val, msg) {
+      function assert(val, msg) {
         if (!val)
           throw new Error(msg || "Assertion failed");
       }
@@ -127466,7 +127451,7 @@ var require_bn4 = __commonJS({
         if (base === "hex") {
           base = 16;
         }
-        assert2(base === (base | 0) && base >= 2 && base <= 36);
+        assert(base === (base | 0) && base >= 2 && base <= 36);
         number = number.toString().replace(/\s+/g, "");
         var start = 0;
         if (number[0] === "-") {
@@ -127500,7 +127485,7 @@ var require_bn4 = __commonJS({
           ];
           this.length = 2;
         } else {
-          assert2(number < 9007199254740992);
+          assert(number < 9007199254740992);
           this.words = [
             number & 67108863,
             number / 67108864 & 67108863,
@@ -127513,7 +127498,7 @@ var require_bn4 = __commonJS({
         this._initArray(this.toArray(), base, endian);
       };
       BN.prototype._initArray = function _initArray(number, base, endian) {
-        assert2(typeof number.length === "number");
+        assert(typeof number.length === "number");
         if (number.length <= 0) {
           this.words = [0];
           this.length = 1;
@@ -127844,7 +127829,7 @@ var require_bn4 = __commonJS({
           }
           return out;
         }
-        assert2(false, "Base should be between 2 and 36");
+        assert(false, "Base should be between 2 and 36");
       };
       BN.prototype.toNumber = function toNumber() {
         var ret = this.words[0];
@@ -127853,7 +127838,7 @@ var require_bn4 = __commonJS({
         } else if (this.length === 3 && this.words[2] === 1) {
           ret += 4503599627370496 + this.words[1] * 67108864;
         } else if (this.length > 2) {
-          assert2(false, "Number can only safely store up to 53 bits");
+          assert(false, "Number can only safely store up to 53 bits");
         }
         return this.negative !== 0 ? -ret : ret;
       };
@@ -127861,7 +127846,7 @@ var require_bn4 = __commonJS({
         return this.toString(16);
       };
       BN.prototype.toBuffer = function toBuffer(endian, length) {
-        assert2(typeof Buffer2 !== "undefined");
+        assert(typeof Buffer2 !== "undefined");
         return this.toArrayLike(Buffer2, endian, length);
       };
       BN.prototype.toArray = function toArray(endian, length) {
@@ -127870,8 +127855,8 @@ var require_bn4 = __commonJS({
       BN.prototype.toArrayLike = function toArrayLike(ArrayType, endian, length) {
         var byteLength = this.byteLength();
         var reqLength = length || Math.max(1, byteLength);
-        assert2(byteLength <= reqLength, "byte array longer than desired length");
-        assert2(reqLength > 0, "Requested array length <= 0");
+        assert(byteLength <= reqLength, "byte array longer than desired length");
+        assert(reqLength > 0, "Requested array length <= 0");
         this.strip();
         var littleEndian = endian === "le";
         var res = new ArrayType(reqLength);
@@ -128014,7 +127999,7 @@ var require_bn4 = __commonJS({
         return this.strip();
       };
       BN.prototype.ior = function ior(num) {
-        assert2((this.negative | num.negative) === 0);
+        assert((this.negative | num.negative) === 0);
         return this.iuor(num);
       };
       BN.prototype.or = function or(num) {
@@ -128041,7 +128026,7 @@ var require_bn4 = __commonJS({
         return this.strip();
       };
       BN.prototype.iand = function iand(num) {
-        assert2((this.negative | num.negative) === 0);
+        assert((this.negative | num.negative) === 0);
         return this.iuand(num);
       };
       BN.prototype.and = function and(num) {
@@ -128076,7 +128061,7 @@ var require_bn4 = __commonJS({
         return this.strip();
       };
       BN.prototype.ixor = function ixor(num) {
-        assert2((this.negative | num.negative) === 0);
+        assert((this.negative | num.negative) === 0);
         return this.iuxor(num);
       };
       BN.prototype.xor = function xor(num) {
@@ -128090,7 +128075,7 @@ var require_bn4 = __commonJS({
         return num.clone().iuxor(this);
       };
       BN.prototype.inotn = function inotn(width) {
-        assert2(typeof width === "number" && width >= 0);
+        assert(typeof width === "number" && width >= 0);
         var bytesNeeded = Math.ceil(width / 26) | 0;
         var bitsLeft = width % 26;
         this._expand(bytesNeeded);
@@ -128109,7 +128094,7 @@ var require_bn4 = __commonJS({
         return this.clone().inotn(width);
       };
       BN.prototype.setn = function setn(bit, val) {
-        assert2(typeof bit === "number" && bit >= 0);
+        assert(typeof bit === "number" && bit >= 0);
         var off = bit / 26 | 0;
         var wbit = bit % 26;
         this._expand(off + 1);
@@ -128976,8 +128961,8 @@ var require_bn4 = __commonJS({
         for (i = 2 * len; i < N; ++i) {
           rws[i] = 0;
         }
-        assert2(carry === 0);
-        assert2((carry & ~8191) === 0);
+        assert(carry === 0);
+        assert((carry & ~8191) === 0);
       };
       FFTM.prototype.stub = function stub(N) {
         var ph = new Array(N);
@@ -129029,8 +129014,8 @@ var require_bn4 = __commonJS({
         return this.clone().mulTo(num, this);
       };
       BN.prototype.imuln = function imuln(num) {
-        assert2(typeof num === "number");
-        assert2(num < 67108864);
+        assert(typeof num === "number");
+        assert(num < 67108864);
         var carry = 0;
         for (var i = 0; i < this.length; i++) {
           var w = (this.words[i] | 0) * num;
@@ -129074,7 +129059,7 @@ var require_bn4 = __commonJS({
         return res;
       };
       BN.prototype.iushln = function iushln(bits) {
-        assert2(typeof bits === "number" && bits >= 0);
+        assert(typeof bits === "number" && bits >= 0);
         var r = bits % 26;
         var s = (bits - r) / 26;
         var carryMask = 67108863 >>> 26 - r << 26 - r;
@@ -129104,11 +129089,11 @@ var require_bn4 = __commonJS({
         return this.strip();
       };
       BN.prototype.ishln = function ishln(bits) {
-        assert2(this.negative === 0);
+        assert(this.negative === 0);
         return this.iushln(bits);
       };
       BN.prototype.iushrn = function iushrn(bits, hint, extended) {
-        assert2(typeof bits === "number" && bits >= 0);
+        assert(typeof bits === "number" && bits >= 0);
         var h;
         if (hint) {
           h = (hint - hint % 26) / 26;
@@ -129153,7 +129138,7 @@ var require_bn4 = __commonJS({
         return this.strip();
       };
       BN.prototype.ishrn = function ishrn(bits, hint, extended) {
-        assert2(this.negative === 0);
+        assert(this.negative === 0);
         return this.iushrn(bits, hint, extended);
       };
       BN.prototype.shln = function shln(bits) {
@@ -129169,7 +129154,7 @@ var require_bn4 = __commonJS({
         return this.clone().iushrn(bits);
       };
       BN.prototype.testn = function testn(bit) {
-        assert2(typeof bit === "number" && bit >= 0);
+        assert(typeof bit === "number" && bit >= 0);
         var r = bit % 26;
         var s = (bit - r) / 26;
         var q = 1 << r;
@@ -129179,10 +129164,10 @@ var require_bn4 = __commonJS({
         return !!(w & q);
       };
       BN.prototype.imaskn = function imaskn(bits) {
-        assert2(typeof bits === "number" && bits >= 0);
+        assert(typeof bits === "number" && bits >= 0);
         var r = bits % 26;
         var s = (bits - r) / 26;
-        assert2(this.negative === 0, "imaskn works only with positive numbers");
+        assert(this.negative === 0, "imaskn works only with positive numbers");
         if (this.length <= s) {
           return this;
         }
@@ -129200,8 +129185,8 @@ var require_bn4 = __commonJS({
         return this.clone().imaskn(bits);
       };
       BN.prototype.iaddn = function iaddn(num) {
-        assert2(typeof num === "number");
-        assert2(num < 67108864);
+        assert(typeof num === "number");
+        assert(num < 67108864);
         if (num < 0)
           return this.isubn(-num);
         if (this.negative !== 0) {
@@ -129231,8 +129216,8 @@ var require_bn4 = __commonJS({
         return this;
       };
       BN.prototype.isubn = function isubn(num) {
-        assert2(typeof num === "number");
-        assert2(num < 67108864);
+        assert(typeof num === "number");
+        assert(num < 67108864);
         if (num < 0)
           return this.iaddn(-num);
         if (this.negative !== 0) {
@@ -129286,7 +129271,7 @@ var require_bn4 = __commonJS({
         }
         if (carry === 0)
           return this.strip();
-        assert2(carry === -1);
+        assert(carry === -1);
         carry = 0;
         for (i = 0; i < this.length; i++) {
           w = -(this.words[i] | 0) + carry;
@@ -129354,7 +129339,7 @@ var require_bn4 = __commonJS({
         };
       };
       BN.prototype.divmod = function divmod(num, mode, positive) {
-        assert2(!num.isZero());
+        assert(!num.isZero());
         if (this.isZero()) {
           return {
             div: new BN(0),
@@ -129449,7 +129434,7 @@ var require_bn4 = __commonJS({
         return dm.div.negative !== 0 ? dm.div.isubn(1) : dm.div.iaddn(1);
       };
       BN.prototype.modn = function modn(num) {
-        assert2(num <= 67108863);
+        assert(num <= 67108863);
         var p = (1 << 26) % num;
         var acc = 0;
         for (var i = this.length - 1; i >= 0; i--) {
@@ -129458,7 +129443,7 @@ var require_bn4 = __commonJS({
         return acc;
       };
       BN.prototype.idivn = function idivn(num) {
-        assert2(num <= 67108863);
+        assert(num <= 67108863);
         var carry = 0;
         for (var i = this.length - 1; i >= 0; i--) {
           var w = (this.words[i] | 0) + carry * 67108864;
@@ -129471,8 +129456,8 @@ var require_bn4 = __commonJS({
         return this.clone().idivn(num);
       };
       BN.prototype.egcd = function egcd(p) {
-        assert2(p.negative === 0);
-        assert2(!p.isZero());
+        assert(p.negative === 0);
+        assert(!p.isZero());
         var x = this;
         var y = p.clone();
         if (x.negative !== 0) {
@@ -129536,8 +129521,8 @@ var require_bn4 = __commonJS({
         };
       };
       BN.prototype._invmp = function _invmp(p) {
-        assert2(p.negative === 0);
-        assert2(!p.isZero());
+        assert(p.negative === 0);
+        assert(!p.isZero());
         var a = this;
         var b = p.clone();
         if (a.negative !== 0) {
@@ -129635,7 +129620,7 @@ var require_bn4 = __commonJS({
         return this.words[0] & num;
       };
       BN.prototype.bincn = function bincn(bit) {
-        assert2(typeof bit === "number");
+        assert(typeof bit === "number");
         var r = bit % 26;
         var s = (bit - r) / 26;
         var q = 1 << r;
@@ -129675,7 +129660,7 @@ var require_bn4 = __commonJS({
           if (negative) {
             num = -num;
           }
-          assert2(num <= 67108863, "Number is too big");
+          assert(num <= 67108863, "Number is too big");
           var w = this.words[0] | 0;
           res = w === num ? 0 : w < num ? -1 : 1;
         }
@@ -129747,12 +129732,12 @@ var require_bn4 = __commonJS({
         return new Red(num);
       };
       BN.prototype.toRed = function toRed(ctx) {
-        assert2(!this.red, "Already a number in reduction context");
-        assert2(this.negative === 0, "red works only with positives");
+        assert(!this.red, "Already a number in reduction context");
+        assert(this.negative === 0, "red works only with positives");
         return ctx.convertTo(this)._forceRed(ctx);
       };
       BN.prototype.fromRed = function fromRed() {
-        assert2(this.red, "fromRed works only with numbers in reduction context");
+        assert(this.red, "fromRed works only with numbers in reduction context");
         return this.red.convertFrom(this);
       };
       BN.prototype._forceRed = function _forceRed(ctx) {
@@ -129760,66 +129745,66 @@ var require_bn4 = __commonJS({
         return this;
       };
       BN.prototype.forceRed = function forceRed(ctx) {
-        assert2(!this.red, "Already a number in reduction context");
+        assert(!this.red, "Already a number in reduction context");
         return this._forceRed(ctx);
       };
       BN.prototype.redAdd = function redAdd(num) {
-        assert2(this.red, "redAdd works only with red numbers");
+        assert(this.red, "redAdd works only with red numbers");
         return this.red.add(this, num);
       };
       BN.prototype.redIAdd = function redIAdd(num) {
-        assert2(this.red, "redIAdd works only with red numbers");
+        assert(this.red, "redIAdd works only with red numbers");
         return this.red.iadd(this, num);
       };
       BN.prototype.redSub = function redSub(num) {
-        assert2(this.red, "redSub works only with red numbers");
+        assert(this.red, "redSub works only with red numbers");
         return this.red.sub(this, num);
       };
       BN.prototype.redISub = function redISub(num) {
-        assert2(this.red, "redISub works only with red numbers");
+        assert(this.red, "redISub works only with red numbers");
         return this.red.isub(this, num);
       };
       BN.prototype.redShl = function redShl(num) {
-        assert2(this.red, "redShl works only with red numbers");
+        assert(this.red, "redShl works only with red numbers");
         return this.red.shl(this, num);
       };
       BN.prototype.redMul = function redMul(num) {
-        assert2(this.red, "redMul works only with red numbers");
+        assert(this.red, "redMul works only with red numbers");
         this.red._verify2(this, num);
         return this.red.mul(this, num);
       };
       BN.prototype.redIMul = function redIMul(num) {
-        assert2(this.red, "redMul works only with red numbers");
+        assert(this.red, "redMul works only with red numbers");
         this.red._verify2(this, num);
         return this.red.imul(this, num);
       };
       BN.prototype.redSqr = function redSqr() {
-        assert2(this.red, "redSqr works only with red numbers");
+        assert(this.red, "redSqr works only with red numbers");
         this.red._verify1(this);
         return this.red.sqr(this);
       };
       BN.prototype.redISqr = function redISqr() {
-        assert2(this.red, "redISqr works only with red numbers");
+        assert(this.red, "redISqr works only with red numbers");
         this.red._verify1(this);
         return this.red.isqr(this);
       };
       BN.prototype.redSqrt = function redSqrt() {
-        assert2(this.red, "redSqrt works only with red numbers");
+        assert(this.red, "redSqrt works only with red numbers");
         this.red._verify1(this);
         return this.red.sqrt(this);
       };
       BN.prototype.redInvm = function redInvm() {
-        assert2(this.red, "redInvm works only with red numbers");
+        assert(this.red, "redInvm works only with red numbers");
         this.red._verify1(this);
         return this.red.invm(this);
       };
       BN.prototype.redNeg = function redNeg() {
-        assert2(this.red, "redNeg works only with red numbers");
+        assert(this.red, "redNeg works only with red numbers");
         this.red._verify1(this);
         return this.red.neg(this);
       };
       BN.prototype.redPow = function redPow(num) {
-        assert2(this.red && !num.red, "redPow(normalNum)");
+        assert(this.red && !num.red, "redPow(normalNum)");
         this.red._verify1(this);
         return this.red.pow(this, num);
       };
@@ -129983,18 +129968,18 @@ var require_bn4 = __commonJS({
           this.m = prime.p;
           this.prime = prime;
         } else {
-          assert2(m.gtn(1), "modulus must be greater than 1");
+          assert(m.gtn(1), "modulus must be greater than 1");
           this.m = m;
           this.prime = null;
         }
       }
       Red.prototype._verify1 = function _verify1(a) {
-        assert2(a.negative === 0, "red works only with positives");
-        assert2(a.red, "red works only with red numbers");
+        assert(a.negative === 0, "red works only with positives");
+        assert(a.red, "red works only with red numbers");
       };
       Red.prototype._verify2 = function _verify2(a, b) {
-        assert2((a.negative | b.negative) === 0, "red works only with positives");
-        assert2(
+        assert((a.negative | b.negative) === 0, "red works only with positives");
+        assert(
           a.red && a.red === b.red,
           "red works only with red numbers"
         );
@@ -130064,7 +130049,7 @@ var require_bn4 = __commonJS({
         if (a.isZero())
           return a.clone();
         var mod3 = this.m.andln(3);
-        assert2(mod3 % 2 === 1);
+        assert(mod3 % 2 === 1);
         if (mod3 === 3) {
           var pow = this.m.add(new BN(1)).iushrn(2);
           return this.pow(a, pow);
@@ -130075,7 +130060,7 @@ var require_bn4 = __commonJS({
           s++;
           q.iushrn(1);
         }
-        assert2(!q.isZero());
+        assert(!q.isZero());
         var one = new BN(1).toRed(this);
         var nOne = one.redNeg();
         var lpow = this.m.subn(1).iushrn(1);
@@ -130093,7 +130078,7 @@ var require_bn4 = __commonJS({
           for (var i = 0; tmp.cmp(one) !== 0; i++) {
             tmp = tmp.redSqr();
           }
-          assert2(i < m);
+          assert(i < m);
           var b = this.pow(c, new BN(1).iushln(m - i - 1));
           r = r.redMul(b);
           c = b.redSqr();
@@ -130653,7 +130638,7 @@ var require_assert2 = __commonJS({
       }
     }
     exports2.output = output;
-    var assert2 = {
+    var assert = {
       number,
       bool,
       bytes,
@@ -130661,7 +130646,7 @@ var require_assert2 = __commonJS({
       exists,
       output
     };
-    exports2.default = assert2;
+    exports2.default = assert;
   }
 });
 
@@ -148868,7 +148853,7 @@ var require_tunnel = __commonJS({
     var http = require("http");
     var https = require("https");
     var events = require("events");
-    var assert2 = require("assert");
+    var assert = require("assert");
     var util = require("util");
     exports2.httpOverHttp = httpOverHttp;
     exports2.httpsOverHttp = httpsOverHttp;
@@ -150489,7 +150474,7 @@ var require_package2 = __commonJS({
       license: "BUSL-1.1",
       scripts: {
         build: "node esbuild.config.mjs",
-        start: "ts-node -r dotenv/config ./src/index.ts",
+        start: "tsx -r dotenv/config ./src/index.ts",
         prepare: "husky install",
         prettier: "prettier --write .",
         "prettier:ci": "npx prettier --check .",
@@ -150500,32 +150485,32 @@ var require_package2 = __commonJS({
       dependencies: {},
       devDependencies: {
         "@actions/core": "^1.10.1",
-        "@commitlint/cli": "^17.7.2",
-        "@commitlint/config-conventional": "^17.7.0",
+        "@commitlint/cli": "^17.8.0",
+        "@commitlint/config-conventional": "^17.8.0",
         "@ethereum-sourcify/bytecode-utils": "^1.2.0",
         "@ethereum-sourcify/lib-sourcify": "^1.3.2",
         "@gearbox-protocol/eslint-config": "2.0.0-next.0",
         "@gearbox-protocol/prettier-config": "2.0.0-next.0",
-        "@gearbox-protocol/sdk": "^3.0.0-next.14",
+        "@gearbox-protocol/sdk": "^3.0.0-next.36",
         "@safe-global/api-kit": "^1.3.1",
         "@safe-global/protocol-kit": "^1.3.0",
         "@safe-global/safe-core-sdk-types": "^2.3.0",
         "@types/lodash": "^4.14.199",
-        "@types/node": "^20.8.2",
-        abitype: "^0.9.9",
+        "@types/node": "^20.8.6",
+        abitype: "^0.10.1",
         chalk: "^4.1.2",
-        commander: "^11.0.0",
+        commander: "^11.1.0",
         "date-fns": "^2.30.0",
         dotenv: "^16.3.1",
         esbuild: "^0.19.4",
-        eslint: "^8.50.0",
+        eslint: "^8.51.0",
         ethers: "5.7.2",
         husky: "^8.0.3",
-        "lint-staged": "^14.0.1",
+        "lint-staged": "^15.0.1",
         lodash: "^4.17.21",
         "p-retry": "^4.6.2",
         prettier: "^3.0.3",
-        "ts-node": "^10.9.1",
+        tsx: "^3.13.0",
         tslog: "^4.9.2",
         typescript: "^5.2.2"
       },
@@ -151139,8 +151124,10 @@ var levels = {
   fatal: 6
 };
 var _a;
+var minLevel = levels[((_a = process.env.LOG_LEVEL) == null ? void 0 : _a.toLowerCase()) ?? "info"] ?? 3;
 var logger = new Logger({
-  minLevel: levels[((_a = process.env.LOG_LEVEL) == null ? void 0 : _a.toLowerCase()) ?? "info"] ?? 3
+  prettyLogTemplate: minLevel < 3 ? "{{logLevelName}}	{{filePathWithLine}}	{{name}}	" : "{{logLevelName}}	{{name}}	",
+  minLevel
 });
 var log_default = logger;
 
@@ -151466,7 +151453,7 @@ var AuditChecker = class {
   async setup() {
     (0, import_node_fs.mkdirSync)(__privateGet(this, _sandboxDir), { recursive: true });
     await clearDir(__privateGet(this, _sandboxDir));
-    __privateGet(this, _logger).debug(`Cleared sandbox dir ${__privateGet(this, _sandboxDir)}`);
+    __privateGet(this, _logger).info("Setting up audit repositories");
     for (const [repo, repoAudits] of Object.entries(audits)) {
       for (const audit of repoAudits) {
         await __privateMethod(this, _checkoutAudit, checkoutAudit_fn).call(this, repo, audit);
@@ -151504,15 +151491,7 @@ auditFile_fn = async function(file) {
     return file;
   }
   __privateGet(this, _logger).debug(`Checking audits for ${path4} in ${repo}`);
-  const matches = await __privateMethod(this, _findMatches, findMatches_fn).call(this, file);
-  if (!matches) {
-    __privateGet(this, _logger).warn(`no matches for ${path4} in ${repo}`);
-  } else {
-    __privateGet(this, _logger).debug(
-      `Found ${matches.length} matches for ${path4} in ${repo}`
-    );
-    file.audits = matches;
-  }
+  file.audits = await __privateMethod(this, _findMatches, findMatches_fn).call(this, file);
   return file;
 };
 _findMatches = new WeakSet();
@@ -151596,7 +151575,7 @@ var SafeBase = class {
 _safe = new WeakMap();
 
 // src/Create2Verifier.ts
-var _sandboxDir2, _auditor, _setupMetaRepos, setupMetaRepos_fn, _verifyBatchAndMeta, verifyBatchAndMeta_fn, _verifySafeTx, verifySafeTx_fn, _verify, verify_fn, _verifyCreate2Tx, verifyCreate2Tx_fn;
+var _logger2, _sandboxDir2, _auditor, _output, _setupMetaRepos, setupMetaRepos_fn, _verifyBatchAndMeta, verifyBatchAndMeta_fn, _verifySafeTx, verifySafeTx_fn, _verify, verify_fn, _verifyCreate2Tx, verifyCreate2Tx_fn;
 var _Create2Verifier = class _Create2Verifier extends SafeBase {
   constructor(options) {
     const provider = new import_ethers3.ethers.providers.StaticJsonRpcProvider(
@@ -151617,10 +151596,16 @@ var _Create2Verifier = class _Create2Verifier extends SafeBase {
     __privateAdd(this, _verifySafeTx);
     __privateAdd(this, _verify);
     __privateAdd(this, _verifyCreate2Tx);
+    __privateAdd(this, _logger2, log_default.getSubLogger({ name: "verifier" }));
     __privateAdd(this, _sandboxDir2, void 0);
     __privateAdd(this, _auditor, void 0);
+    __privateAdd(this, _output, []);
     if (options.sandboxDir) {
       __privateSet(this, _sandboxDir2, import_node_path3.default.resolve(options.sandboxDir));
+      try {
+        (0, import_node_fs2.mkdirSync)(__privateGet(this, _sandboxDir2));
+      } catch {
+      }
     } else {
       __privateSet(this, _sandboxDir2, (0, import_node_fs2.mkdtempSync)("cr2ver", { encoding: "utf8" }));
     }
@@ -151636,6 +151621,8 @@ if no options are provided, will verify all pending transactions from safe multi
         "--sandbox-dir [dir]",
         "directory for temporary files, defaults to tmp dir"
       )
+    ).addOption(
+      new Option("--out-file [json]", "save output result into json file")
     ).addOption(
       new Option(
         "--mainnet-rpc <url>",
@@ -151665,35 +151652,51 @@ if no options are provided, will verify all pending transactions from safe multi
   }
   async verify(opts) {
     const { batchFile, metaFile, safeTxHashes, skipCleanup } = opts;
-    if (!skipCleanup) {
-      await __privateMethod(this, _setupMetaRepos, setupMetaRepos_fn).call(this);
-      await __privateGet(this, _auditor).setup();
-    }
-    if (batchFile && metaFile) {
-      await __privateMethod(this, _verifyBatchAndMeta, verifyBatchAndMeta_fn).call(this, batchFile, metaFile);
-    } else if (safeTxHashes == null ? void 0 : safeTxHashes.length) {
-      for (const safeTxHash of safeTxHashes) {
-        const tx = await this.service.getTransaction(safeTxHash);
-        if (!tx) {
-          throw new Error(`safe tx ${safeTxHash} not found`);
+    try {
+      if (!skipCleanup) {
+        await __privateMethod(this, _setupMetaRepos, setupMetaRepos_fn).call(this);
+        await __privateGet(this, _auditor).setup();
+      }
+      if (batchFile && metaFile) {
+        await __privateMethod(this, _verifyBatchAndMeta, verifyBatchAndMeta_fn).call(this, batchFile, metaFile);
+      } else if (safeTxHashes == null ? void 0 : safeTxHashes.length) {
+        for (const safeTxHash of safeTxHashes) {
+          const tx = await this.service.getTransaction(safeTxHash);
+          if (!tx) {
+            throw new Error(`safe tx ${safeTxHash} not found`);
+          }
+          await __privateMethod(this, _verifySafeTx, verifySafeTx_fn).call(this, tx);
+        }
+      } else {
+        const pendingTransactions = await this.service.getPendingTransactions(
+          this.safeAddress
+        );
+        const pending = getTransactionsToExecute(pendingTransactions);
+        for (const tx of pending) {
+          await __privateMethod(this, _verifySafeTx, verifySafeTx_fn).call(this, tx);
         }
-        await __privateMethod(this, _verifySafeTx, verifySafeTx_fn).call(this, tx);
       }
-    } else {
-      const pendingTransactions = await this.service.getPendingTransactions(
-        this.safeAddress
-      );
-      const pending = getTransactionsToExecute(pendingTransactions);
-      for (const tx of pending) {
-        await __privateMethod(this, _verifySafeTx, verifySafeTx_fn).call(this, tx);
+      if (opts.outFile) {
+        await import_promises3.default.writeFile(
+          opts.outFile,
+          JSON.stringify(__privateGet(this, _output), null, 2),
+          "utf-8"
+        );
+      }
+    } finally {
+      if (!skipCleanup) {
+        await import_promises3.default.rm(__privateGet(this, _sandboxDir2), { force: true, recursive: true });
       }
     }
   }
 };
+_logger2 = new WeakMap();
 _sandboxDir2 = new WeakMap();
 _auditor = new WeakMap();
+_output = new WeakMap();
 _setupMetaRepos = new WeakSet();
 setupMetaRepos_fn = async function() {
+  __privateGet(this, _logger2).info("setting up meta repositories");
   await clearDir(__privateGet(this, _sandboxDir2));
   await Promise.all(
     DEPLOY_REPOS.map(
@@ -151703,6 +151706,7 @@ setupMetaRepos_fn = async function() {
       })
     )
   );
+  __privateGet(this, _logger2).debug("meta repositories setup complete");
 };
 _verifyBatchAndMeta = new WeakSet();
 verifyBatchAndMeta_fn = async function(batchFile, metaFile) {
@@ -151711,24 +151715,28 @@ verifyBatchAndMeta_fn = async function(batchFile, metaFile) {
   const batch = JSON.parse(batchContent);
   const meta2 = JSON.parse(metaContent);
   const create2txs = getCreate2transactions(batch);
-  await __privateMethod(this, _verify, verify_fn).call(this, create2txs, meta2);
+  const results = await __privateMethod(this, _verify, verify_fn).call(this, create2txs, meta2);
+  __privateGet(this, _output).push({ results });
 };
 _verifySafeTx = new WeakSet();
 verifySafeTx_fn = async function(tx) {
-  console.info(`Verifying tx ${import_chalk.default.green(tx.safeTxHash)}...`);
+  __privateGet(this, _logger2).info(`Verifying tx ${import_chalk.default.green(tx.safeTxHash)}...`);
   await import_promises3.default.writeFile(
     import_node_path3.default.resolve(__privateGet(this, _sandboxDir2), `${tx.safeTxHash}.tx.json`),
     JSON.stringify(tx, null, 2)
   );
   const meta2 = await getDeployMeta(tx.safeTxHash, __privateGet(this, _sandboxDir2));
   const create2txs = getCreate2transactions(tx);
-  await __privateMethod(this, _verify, verify_fn).call(this, create2txs, meta2);
+  const results = await __privateMethod(this, _verify, verify_fn).call(this, create2txs, meta2);
+  __privateGet(this, _output).push({ results, safeTxHash: tx.safeTxHash });
 };
 _verify = new WeakSet();
 verify_fn = async function(create2txs, meta2) {
+  var _a2;
   const addressToMeta = new Map(
     Object.values(meta2).map((c) => [c.contractAddress, c])
   );
+  const results = [];
   for (const tx2 of create2txs) {
     const address = create2Address(tx2);
     const metaContract = addressToMeta.get(address);
@@ -151738,8 +151746,34 @@ verify_fn = async function(create2txs, meta2) {
       );
     }
     const match = await __privateMethod(this, _verifyCreate2Tx, verifyCreate2Tx_fn).call(this, tx2, metaContract);
-    console.log(JSON.stringify(match, null, 2));
+    results.push(match);
+    if ("error" in match) {
+      __privateGet(this, _logger2).error(
+        `${import_chalk.default.red(match.contract)} is not verified: ${match.error}`
+      );
+      process.exitCode = 1;
+    } else {
+      if (match.match === "partial") {
+        __privateGet(this, _logger2).warn(
+          `${import_chalk.default.yellow(match.contract)} is a partial match`
+        );
+      } else {
+        __privateGet(this, _logger2).debug(
+          `${import_chalk.default.green(match.contract)} is a perfect match`
+        );
+      }
+      for (const file of match.files) {
+        if (file.gearbox && !((_a2 = file.audits) == null ? void 0 : _a2.length)) {
+          __privateGet(this, _logger2).warn(
+            `No audits for file ${import_chalk.default.yellow(file.path)} in ${import_chalk.default.yellow(
+              file.repo
+            )} for contract ${import_chalk.default.yellow(match.contract)}`
+          );
+        }
+      }
+    }
   }
+  return results;
 };
 _verifyCreate2Tx = new WeakSet();
 verifyCreate2Tx_fn = async function(tx, meta2) {
@@ -151849,7 +151883,6 @@ verifyCreate2Tx_fn = async function(tx, meta2) {
 var Create2Verifier = _Create2Verifier;
 
 // src/SafeHelper.ts
-var import_strict = __toESM(require("assert/strict"));
 var import_core = __toESM(require_core2());
 var import_chalk2 = __toESM(require_source());
 var import_ethers4 = __toESM(require_lib40());
@@ -151985,9 +152018,13 @@ impersonateSafe_fn = async function() {
     data: addOwnerTx.data.data
   });
   const receipt = await this.provider.getTransactionReceipt(hash);
-  import_strict.default.ok(receipt.status, "failed to add owner to safe");
+  if (!receipt.status) {
+    throw new Error("failed to add owner to safe");
+  }
   const owners = await this.safe.getOwners();
-  import_strict.default.ok(owners.includes(ownerAddress), "owner was not added");
+  if (!owners.includes(ownerAddress)) {
+    throw new Error("owner was not added");
+  }
   console.log("added fake owner to safe and set threshold to 1");
   if (!__privateGet(this, _tenderly)) {
     await stopImpersonate(this.provider, this.safeAddress);
@@ -151996,10 +152033,11 @@ impersonateSafe_fn = async function() {
 _validateTransaction = new WeakSet();
 validateTransaction_fn = function(timestamp, data) {
   var _a2;
-  import_strict.default.ok(
-    !data.isExecuted,
-    `safe tx already executed in tx ${data.safeTxHash} with nonce ${data.nonce}`
-  );
+  if (data.isExecuted) {
+    throw new Error(
+      `safe tx already executed in tx ${data.safeTxHash} with nonce ${data.nonce}`
+    );
+  }
   if (!data.dataDecoded) {
     console.warn("data decoded is missing");
   }
@@ -152015,32 +152053,34 @@ validateTransaction_fn = function(timestamp, data) {
 _validateMultisend = new WeakSet();
 validateMultisend_fn = function(timestamp, data) {
   var _a2;
-  import_strict.default.equal(
-    data.dataDecoded.parameters.length,
-    1,
-    "expected multiSend transaction with 1 parameter"
-  );
-  import_strict.default.equal(
-    data.dataDecoded.parameters[0].name,
-    "transactions",
-    "expected multiSend transactions"
-  );
+  if (data.dataDecoded.parameters.length !== 1) {
+    throw new Error("expected multiSend transaction with 1 parameter");
+  }
+  if (data.dataDecoded.parameters[0].name !== "transactions") {
+    throw new Error("expected multiSend transactions");
+  }
   const txs = data.dataDecoded.parameters[0].valueDecoded;
-  import_strict.default.notEqual(txs.length, 0, "expected some transactions");
+  if (txs.length === 0) {
+    throw new Error("expected some transactions");
+  }
   let eta = 0;
   let isQueue = false;
   let isExecute = false;
   for (const tx of txs) {
     const method = (_a2 = tx.dataDecoded) == null ? void 0 : _a2.method;
     if (method === "queueTransaction" || method === "executeTransaction") {
-      import_strict.default.equal(tx.dataDecoded.parameters.length, 5);
+      if (tx.dataDecoded.parameters.length !== 5) {
+        throw new Error(`${method} expects 5 arguments`);
+      }
       eta = Math.max(parseInt(tx.dataDecoded.parameters[4].value, 10), eta);
       isQueue || (isQueue = method === "queueTransaction");
       isExecute || (isExecute = method === "executeTransaction");
     }
   }
   if (eta && isQueue) {
-    import_strict.default.ok(eta > timestamp, `ETA is outdated: ${eta} <= ${timestamp}`);
+    if (eta <= timestamp) {
+      throw new Error(`ETA is outdated: ${eta} <= ${timestamp}`);
+    }
   }
   return {
     multisend: true,
@@ -152055,11 +152095,17 @@ validateSingle_fn = function(timestamp, data) {
   const method = (_a2 = data.dataDecoded) == null ? void 0 : _a2.method;
   if (method === "queueTransaction" || method === "executeTransaction") {
     const isQueue = method === "queueTransaction";
-    import_strict.default.equal(data.dataDecoded.parameters.length, 5);
+    if (data.dataDecoded.parameters.length !== 5) {
+      throw new Error(`${method} expects 5 args`);
+    }
     const etaP = data.dataDecoded.parameters.find((p) => p.name === "eta");
-    import_strict.default.ok(etaP, "eta parameter not found");
+    if (!etaP) {
+      throw new Error("eta parameter not found");
+    }
     const eta = parseInt(data.dataDecoded.parameters[4].value, 10);
-    import_strict.default.ok(eta > timestamp, "ETA is outdated");
+    if (eta <= timestamp) {
+      throw new Error("ETA is outdated");
+    }
     return {
       isQueue,
       isExecute: !isQueue,
@@ -152083,7 +152129,9 @@ execute_fn = async function(tx) {
   const receipt = await Promise.resolve(
     (_a2 = executeTxResponse.transactionResponse) == null ? void 0 : _a2.wait()
   );
-  import_strict.default.ok(receipt == null ? void 0 : receipt.status, "failed to execute transaction");
+  if (!(receipt == null ? void 0 : receipt.status)) {
+    throw new Error("failed to execute transaction");
+  }
   if ("safeTxHash" in tx) {
     console.log(`executed safe tx ${tx.safeTxHash} with nonce ${tx.nonce}`);
   } else {