@gearbox-protocol/deploy-tools 1.1.4 → 1.1.5

package/dist/index.js

@@ -7112,14 +7112,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 +7129,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 +7158,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 +7174,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 +10004,7 @@ var require_assert = __commonJS({
       }
     }
     exports2.output = output;
-    var assert2 = {
+    var assert = {
       number,
       bool,
       bytes,
@@ -10012,7 +10012,7 @@ var require_assert = __commonJS({
       exists,
       output
     };
-    exports2.default = assert2;
+    exports2.default = assert;
   }
 });
 
@@ -42624,7 +42624,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 +42990,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 +43056,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 +59918,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 +59988,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 +60021,7 @@ var require_bn = __commonJS({
           ];
           this.length = 2;
         } else {
-          assert2(number < 9007199254740992);
+          assert(number < 9007199254740992);
           this.words = [
             number & 67108863,
             number / 67108864 & 67108863,
@@ -60034,7 +60034,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 +60081,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 +60142,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 +60402,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 +60411,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 +60436,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 +60619,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 +60646,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 +60681,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 +60695,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 +60714,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 +61580,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 +61636,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 +61681,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 +61711,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 +61760,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 +61776,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 +61786,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 +61807,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 +61838,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 +61893,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 +61961,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 +62059,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 +62074,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 +62088,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 +62153,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 +62252,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 +62292,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 +62364,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 +62377,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 +62604,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 +62686,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 +62697,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 +62715,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 +71309,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 +71379,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 +71412,7 @@ var require_bn2 = __commonJS({
           ];
           this.length = 2;
         } else {
-          assert2(number < 9007199254740992);
+          assert(number < 9007199254740992);
           this.words = [
             number & 67108863,
             number / 67108864 & 67108863,
@@ -71425,7 +71425,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 +71770,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 +71779,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 +71787,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 +71796,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 +71940,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 +71967,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 +72002,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 +72016,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 +72035,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 +72902,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 +72955,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 +73000,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 +73030,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 +73079,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 +73095,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 +73105,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 +73126,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 +73157,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 +73212,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 +73280,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 +73375,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 +73384,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 +73397,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 +73462,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 +73561,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 +73601,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 +73673,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 +73686,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 +73913,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 +73994,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 +74005,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 +74023,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 +74160,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 +74399,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 +74430,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 +74474,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 +74625,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 +74721,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 +74755,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 +75547,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 +75559,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 +75856,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 +75961,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 +76102,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 +76136,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 +76301,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 +76415,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 +76488,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 +76748,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 +77423,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 +77438,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 +78271,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 +78282,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 +78445,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 +78460,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 +78501,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 +78539,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 +78600,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 +78611,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 +78633,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 +78782,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 +78915,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 +78958,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 +79010,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 +79033,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 +79046,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 +79083,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 +100168,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 +100200,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 +100290,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 +100373,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 +100406,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 +100427,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 +124568,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 +124634,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 +124668,7 @@ var require_bn3 = __commonJS({
           ];
           this.length = 2;
         } else {
-          assert2(number < 9007199254740992);
+          assert(number < 9007199254740992);
           this.words = [
             number & 67108863,
             number / 67108864 & 67108863,
@@ -124681,7 +124681,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 +125012,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 +125021,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 +125029,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 +125038,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 +125182,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 +125209,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 +125244,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 +125258,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 +125277,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 +126144,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 +126197,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 +126242,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 +126272,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 +126321,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 +126337,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 +126347,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 +126368,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 +126399,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 +126454,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 +126522,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 +126617,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 +126626,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 +126639,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 +126704,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 +126803,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 +126843,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 +126915,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 +126928,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 +127151,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 +127232,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 +127243,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 +127261,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 +127400,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 +127466,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 +127500,7 @@ var require_bn4 = __commonJS({
           ];
           this.length = 2;
         } else {
-          assert2(number < 9007199254740992);
+          assert(number < 9007199254740992);
           this.words = [
             number & 67108863,
             number / 67108864 & 67108863,
@@ -127513,7 +127513,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 +127844,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 +127853,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 +127861,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 +127870,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 +128014,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 +128041,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 +128076,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 +128090,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 +128109,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 +128976,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 +129029,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 +129074,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 +129104,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 +129153,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 +129169,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 +129179,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 +129200,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 +129231,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 +129286,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 +129354,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 +129449,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 +129458,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 +129471,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 +129536,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 +129635,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 +129675,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 +129747,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 +129760,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 +129983,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 +130064,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 +130075,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 +130093,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 +130653,7 @@ var require_assert2 = __commonJS({
       }
     }
     exports2.output = output;
-    var assert2 = {
+    var assert = {
       number,
       bool,
       bytes,
@@ -130661,7 +130661,7 @@ var require_assert2 = __commonJS({
       exists,
       output
     };
-    exports2.default = assert2;
+    exports2.default = assert;
   }
 });
 
@@ -148868,7 +148868,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;
@@ -151849,7 +151849,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 +151984,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 +151999,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 +152019,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 +152061,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 +152095,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 {