@leofcoin/chain 1.5.64 → 1.5.66

package/exports/browser/{node-browser-0Ly80awM.js → node-browser-TcXF8FDB.js}

@@ -107,7 +107,8 @@ const debug$1 = (target, text) => {
     globalThis.DEBUG === 'true' ||
     globalThis.DEBUG === true ||
     globalThis.DEBUG?.indexOf(target) !== -1 ||
-    globalThis.DEBUG?.indexOf('*') !== -1
+    globalThis.DEBUG?.indexOf('*') !== -1 ||
+    globalThis.DEBUG?.indexOf(target.split('/')[0]) !== -1
   )
     if (text) console.log('\x1b[34m\x1b[1m%s', `${target}: ${text}`, '\x1b[0m');
     else console.log('\x1b[34m\x1b[1m%s', `${target}`, '\x1b[0m');
@@ -12858,6 +12859,7 @@ const nothingFoundError = (hash) => {
 };
 
 const isBrowser = globalThis.process?.versions?.node ? false : true;
+
 let LeofcoinStorage$1 = class LeofcoinStorage {
     name;
     root;
@@ -12893,7 +12895,7 @@ let LeofcoinStorage$1 = class LeofcoinStorage {
         if (typeof key === 'object')
             return this.many('has', key);
         try {
-            const has = await this.db.get(new KeyPath(key));
+            const has = await this.db.has(new KeyPath(key));
             return Boolean(has);
         }
         catch (e) {
@@ -13106,185 +13108,522 @@ var index$1 = {
     }
 };
 
-var elliptic$2 = {};
-
-var name = "elliptic";
-var version$1 = "6.5.4";
-var description = "EC cryptography";
-var main = "lib/elliptic.js";
-var files = [
-	"lib"
-];
-var scripts = {
-	lint: "eslint lib test",
-	"lint:fix": "npm run lint -- --fix",
-	unit: "istanbul test _mocha --reporter=spec test/index.js",
-	test: "npm run lint && npm run unit",
-	version: "grunt dist && git add dist/"
-};
-var repository = {
-	type: "git",
-	url: "git@github.com:indutny/elliptic"
-};
-var keywords = [
-	"EC",
-	"Elliptic",
-	"curve",
-	"Cryptography"
-];
-var author = "Fedor Indutny <fedor@indutny.com>";
-var license = "MIT";
-var bugs = {
-	url: "https://github.com/indutny/elliptic/issues"
-};
-var homepage = "https://github.com/indutny/elliptic";
-var devDependencies = {
-	brfs: "^2.0.2",
-	coveralls: "^3.1.0",
-	eslint: "^7.6.0",
-	grunt: "^1.2.1",
-	"grunt-browserify": "^5.3.0",
-	"grunt-cli": "^1.3.2",
-	"grunt-contrib-connect": "^3.0.0",
-	"grunt-contrib-copy": "^1.0.0",
-	"grunt-contrib-uglify": "^5.0.0",
-	"grunt-mocha-istanbul": "^5.0.2",
-	"grunt-saucelabs": "^9.0.1",
-	istanbul: "^0.4.5",
-	mocha: "^8.0.1"
-};
-var dependencies = {
-	"bn.js": "^4.11.9",
-	brorand: "^1.1.0",
-	"hash.js": "^1.0.0",
-	"hmac-drbg": "^1.0.1",
-	inherits: "^2.0.4",
-	"minimalistic-assert": "^1.0.1",
-	"minimalistic-crypto-utils": "^1.0.1"
-};
-var require$$0 = {
-	name: name,
-	version: version$1,
-	description: description,
-	main: main,
-	files: files,
-	scripts: scripts,
-	repository: repository,
-	keywords: keywords,
-	author: author,
-	license: license,
-	bugs: bugs,
-	homepage: homepage,
-	devDependencies: devDependencies,
-	dependencies: dependencies
+const errors = {
+  IMPOSSIBLE_CASE: 'Impossible case. Please create issue.',
+  TWEAK_ADD:
+    'The tweak was out of range or the resulted private key is invalid',
+  TWEAK_MUL: 'The tweak was out of range or equal to zero',
+  CONTEXT_RANDOMIZE_UNKNOW: 'Unknow error on context randomization',
+  SECKEY_INVALID: 'Private Key is invalid',
+  PUBKEY_PARSE: 'Public Key could not be parsed',
+  PUBKEY_SERIALIZE: 'Public Key serialization error',
+  PUBKEY_COMBINE: 'The sum of the public keys is not valid',
+  SIG_PARSE: 'Signature could not be parsed',
+  SIGN: 'The nonce generation function failed, or the private key was invalid',
+  RECOVER: 'Public key could not be recover',
+  ECDH: 'Scalar was invalid (zero or overflow)'
 };
 
-var utils$o = {};
-
-var bn = {exports: {}};
+function assert$g (cond, msg) {
+  if (!cond) throw new Error(msg)
+}
 
-(function (module) {
-	(function (module, exports) {
+function isUint8Array (name, value, length) {
+  assert$g(value instanceof Uint8Array, `Expected ${name} to be an Uint8Array`);
 
-	  // Utils
-	  function assert (val, msg) {
-	    if (!val) throw new Error(msg || 'Assertion failed');
-	  }
+  if (length !== undefined) {
+    if (Array.isArray(length)) {
+      const numbers = length.join(', ');
+      const msg = `Expected ${name} to be an Uint8Array with length [${numbers}]`;
+      assert$g(length.includes(value.length), msg);
+    } else {
+      const msg = `Expected ${name} to be an Uint8Array with length ${length}`;
+      assert$g(value.length === length, msg);
+    }
+  }
+}
 
-	  // Could use `inherits` module, but don't want to move from single file
-	  // architecture yet.
-	  function inherits (ctor, superCtor) {
-	    ctor.super_ = superCtor;
-	    var TempCtor = function () {};
-	    TempCtor.prototype = superCtor.prototype;
-	    ctor.prototype = new TempCtor();
-	    ctor.prototype.constructor = ctor;
-	  }
+function isCompressed (value) {
+  assert$g(toTypeString(value) === 'Boolean', 'Expected compressed to be a Boolean');
+}
 
-	  // BN
+function getAssertedOutput (output = (len) => new Uint8Array(len), length) {
+  if (typeof output === 'function') output = output(length);
+  isUint8Array('output', output, length);
+  return output
+}
 
-	  function BN (number, base, endian) {
-	    if (BN.isBN(number)) {
-	      return number;
-	    }
+function toTypeString (value) {
+  return Object.prototype.toString.call(value).slice(8, -1)
+}
 
-	    this.negative = 0;
-	    this.words = null;
-	    this.length = 0;
+var lib = (secp256k1) => {
+  return {
+    contextRandomize (seed) {
+      assert$g(
+        seed === null || seed instanceof Uint8Array,
+        'Expected seed to be an Uint8Array or null'
+      );
+      if (seed !== null) isUint8Array('seed', seed, 32);
 
-	    // Reduction context
-	    this.red = null;
+      switch (secp256k1.contextRandomize(seed)) {
+        case 1:
+          throw new Error(errors.CONTEXT_RANDOMIZE_UNKNOW)
+      }
+    },
 
-	    if (number !== null) {
-	      if (base === 'le' || base === 'be') {
-	        endian = base;
-	        base = 10;
-	      }
+    privateKeyVerify (seckey) {
+      isUint8Array('private key', seckey, 32);
 
-	      this._init(number || 0, base || 10, endian || 'be');
-	    }
-	  }
-	  if (typeof module === 'object') {
-	    module.exports = BN;
-	  } else {
-	    exports.BN = BN;
-	  }
+      return secp256k1.privateKeyVerify(seckey) === 0
+    },
 
-	  BN.BN = BN;
-	  BN.wordSize = 26;
+    privateKeyNegate (seckey) {
+      isUint8Array('private key', seckey, 32);
 
-	  var Buffer;
-	  try {
-	    if (typeof window !== 'undefined' && typeof window.Buffer !== 'undefined') {
-	      Buffer = window.Buffer;
-	    } else {
-	      Buffer = require$$3.Buffer;
-	    }
-	  } catch (e) {
-	  }
+      switch (secp256k1.privateKeyNegate(seckey)) {
+        case 0:
+          return seckey
+        case 1:
+          throw new Error(errors.IMPOSSIBLE_CASE)
+      }
+    },
 
-	  BN.isBN = function isBN (num) {
-	    if (num instanceof BN) {
-	      return true;
-	    }
+    privateKeyTweakAdd (seckey, tweak) {
+      isUint8Array('private key', seckey, 32);
+      isUint8Array('tweak', tweak, 32);
 
-	    return num !== null && typeof num === 'object' &&
-	      num.constructor.wordSize === BN.wordSize && Array.isArray(num.words);
-	  };
+      switch (secp256k1.privateKeyTweakAdd(seckey, tweak)) {
+        case 0:
+          return seckey
+        case 1:
+          throw new Error(errors.TWEAK_ADD)
+      }
+    },
 
-	  BN.max = function max (left, right) {
-	    if (left.cmp(right) > 0) return left;
-	    return right;
-	  };
+    privateKeyTweakMul (seckey, tweak) {
+      isUint8Array('private key', seckey, 32);
+      isUint8Array('tweak', tweak, 32);
 
-	  BN.min = function min (left, right) {
-	    if (left.cmp(right) < 0) return left;
-	    return right;
-	  };
+      switch (secp256k1.privateKeyTweakMul(seckey, tweak)) {
+        case 0:
+          return seckey
+        case 1:
+          throw new Error(errors.TWEAK_MUL)
+      }
+    },
 
-	  BN.prototype._init = function init (number, base, endian) {
-	    if (typeof number === 'number') {
-	      return this._initNumber(number, base, endian);
-	    }
+    publicKeyVerify (pubkey) {
+      isUint8Array('public key', pubkey, [33, 65]);
 
-	    if (typeof number === 'object') {
-	      return this._initArray(number, base, endian);
-	    }
+      return secp256k1.publicKeyVerify(pubkey) === 0
+    },
 
-	    if (base === 'hex') {
-	      base = 16;
-	    }
-	    assert(base === (base | 0) && base >= 2 && base <= 36);
+    publicKeyCreate (seckey, compressed = true, output) {
+      isUint8Array('private key', seckey, 32);
+      isCompressed(compressed);
+      output = getAssertedOutput(output, compressed ? 33 : 65);
 
-	    number = number.toString().replace(/\s+/g, '');
-	    var start = 0;
-	    if (number[0] === '-') {
-	      start++;
-	      this.negative = 1;
-	    }
+      switch (secp256k1.publicKeyCreate(output, seckey)) {
+        case 0:
+          return output
+        case 1:
+          throw new Error(errors.SECKEY_INVALID)
+        case 2:
+          throw new Error(errors.PUBKEY_SERIALIZE)
+      }
+    },
 
-	    if (start < number.length) {
-	      if (base === 16) {
+    publicKeyConvert (pubkey, compressed = true, output) {
+      isUint8Array('public key', pubkey, [33, 65]);
+      isCompressed(compressed);
+      output = getAssertedOutput(output, compressed ? 33 : 65);
+
+      switch (secp256k1.publicKeyConvert(output, pubkey)) {
+        case 0:
+          return output
+        case 1:
+          throw new Error(errors.PUBKEY_PARSE)
+        case 2:
+          throw new Error(errors.PUBKEY_SERIALIZE)
+      }
+    },
+
+    publicKeyNegate (pubkey, compressed = true, output) {
+      isUint8Array('public key', pubkey, [33, 65]);
+      isCompressed(compressed);
+      output = getAssertedOutput(output, compressed ? 33 : 65);
+
+      switch (secp256k1.publicKeyNegate(output, pubkey)) {
+        case 0:
+          return output
+        case 1:
+          throw new Error(errors.PUBKEY_PARSE)
+        case 2:
+          throw new Error(errors.IMPOSSIBLE_CASE)
+        case 3:
+          throw new Error(errors.PUBKEY_SERIALIZE)
+      }
+    },
+
+    publicKeyCombine (pubkeys, compressed = true, output) {
+      assert$g(Array.isArray(pubkeys), 'Expected public keys to be an Array');
+      assert$g(pubkeys.length > 0, 'Expected public keys array will have more than zero items');
+      for (const pubkey of pubkeys) {
+        isUint8Array('public key', pubkey, [33, 65]);
+      }
+      isCompressed(compressed);
+      output = getAssertedOutput(output, compressed ? 33 : 65);
+
+      switch (secp256k1.publicKeyCombine(output, pubkeys)) {
+        case 0:
+          return output
+        case 1:
+          throw new Error(errors.PUBKEY_PARSE)
+        case 2:
+          throw new Error(errors.PUBKEY_COMBINE)
+        case 3:
+          throw new Error(errors.PUBKEY_SERIALIZE)
+      }
+    },
+
+    publicKeyTweakAdd (pubkey, tweak, compressed = true, output) {
+      isUint8Array('public key', pubkey, [33, 65]);
+      isUint8Array('tweak', tweak, 32);
+      isCompressed(compressed);
+      output = getAssertedOutput(output, compressed ? 33 : 65);
+
+      switch (secp256k1.publicKeyTweakAdd(output, pubkey, tweak)) {
+        case 0:
+          return output
+        case 1:
+          throw new Error(errors.PUBKEY_PARSE)
+        case 2:
+          throw new Error(errors.TWEAK_ADD)
+      }
+    },
+
+    publicKeyTweakMul (pubkey, tweak, compressed = true, output) {
+      isUint8Array('public key', pubkey, [33, 65]);
+      isUint8Array('tweak', tweak, 32);
+      isCompressed(compressed);
+      output = getAssertedOutput(output, compressed ? 33 : 65);
+
+      switch (secp256k1.publicKeyTweakMul(output, pubkey, tweak)) {
+        case 0:
+          return output
+        case 1:
+          throw new Error(errors.PUBKEY_PARSE)
+        case 2:
+          throw new Error(errors.TWEAK_MUL)
+      }
+    },
+
+    signatureNormalize (sig) {
+      isUint8Array('signature', sig, 64);
+
+      switch (secp256k1.signatureNormalize(sig)) {
+        case 0:
+          return sig
+        case 1:
+          throw new Error(errors.SIG_PARSE)
+      }
+    },
+
+    signatureExport (sig, output) {
+      isUint8Array('signature', sig, 64);
+      output = getAssertedOutput(output, 72);
+
+      const obj = { output, outputlen: 72 };
+      switch (secp256k1.signatureExport(obj, sig)) {
+        case 0:
+          return output.slice(0, obj.outputlen)
+        case 1:
+          throw new Error(errors.SIG_PARSE)
+        case 2:
+          throw new Error(errors.IMPOSSIBLE_CASE)
+      }
+    },
+
+    signatureImport (sig, output) {
+      isUint8Array('signature', sig);
+      output = getAssertedOutput(output, 64);
+
+      switch (secp256k1.signatureImport(output, sig)) {
+        case 0:
+          return output
+        case 1:
+          throw new Error(errors.SIG_PARSE)
+        case 2:
+          throw new Error(errors.IMPOSSIBLE_CASE)
+      }
+    },
+
+    ecdsaSign (msg32, seckey, options = {}, output) {
+      isUint8Array('message', msg32, 32);
+      isUint8Array('private key', seckey, 32);
+      assert$g(toTypeString(options) === 'Object', 'Expected options to be an Object');
+      if (options.data !== undefined) isUint8Array('options.data', options.data);
+      if (options.noncefn !== undefined) assert$g(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)) {
+        case 0:
+          return obj
+        case 1:
+          throw new Error(errors.SIGN)
+        case 2:
+          throw new Error(errors.IMPOSSIBLE_CASE)
+      }
+    },
+
+    ecdsaVerify (sig, msg32, pubkey) {
+      isUint8Array('signature', sig, 64);
+      isUint8Array('message', msg32, 32);
+      isUint8Array('public key', pubkey, [33, 65]);
+
+      switch (secp256k1.ecdsaVerify(sig, msg32, pubkey)) {
+        case 0:
+          return true
+        case 3:
+          return false
+        case 1:
+          throw new Error(errors.SIG_PARSE)
+        case 2:
+          throw new Error(errors.PUBKEY_PARSE)
+      }
+    },
+
+    ecdsaRecover (sig, recid, msg32, compressed = true, output) {
+      isUint8Array('signature', sig, 64);
+      assert$g(
+        toTypeString(recid) === 'Number' &&
+          recid >= 0 &&
+          recid <= 3,
+        'Expected recovery id to be a Number within interval [0, 3]'
+      );
+      isUint8Array('message', msg32, 32);
+      isCompressed(compressed);
+      output = getAssertedOutput(output, compressed ? 33 : 65);
+
+      switch (secp256k1.ecdsaRecover(output, sig, recid, msg32)) {
+        case 0:
+          return output
+        case 1:
+          throw new Error(errors.SIG_PARSE)
+        case 2:
+          throw new Error(errors.RECOVER)
+        case 3:
+          throw new Error(errors.IMPOSSIBLE_CASE)
+      }
+    },
+
+    ecdh (pubkey, seckey, options = {}, output) {
+      isUint8Array('public key', pubkey, [33, 65]);
+      isUint8Array('private key', seckey, 32);
+      assert$g(toTypeString(options) === 'Object', 'Expected options to be an Object');
+      if (options.data !== undefined) isUint8Array('options.data', options.data);
+      if (options.hashfn !== undefined) {
+        assert$g(toTypeString(options.hashfn) === 'Function', 'Expected options.hashfn to be a Function');
+        if (options.xbuf !== undefined) isUint8Array('options.xbuf', options.xbuf, 32);
+        if (options.ybuf !== undefined) isUint8Array('options.ybuf', options.ybuf, 32);
+        isUint8Array('output', output);
+      } else {
+        output = getAssertedOutput(output, 32);
+      }
+
+      switch (secp256k1.ecdh(output, pubkey, seckey, options.data, options.hashfn, options.xbuf, options.ybuf)) {
+        case 0:
+          return output
+        case 1:
+          throw new Error(errors.PUBKEY_PARSE)
+        case 2:
+          throw new Error(errors.ECDH)
+      }
+    }
+  }
+};
+
+var elliptic$2 = {};
+
+var name = "elliptic";
+var version$1 = "6.5.4";
+var description = "EC cryptography";
+var main = "lib/elliptic.js";
+var files = [
+	"lib"
+];
+var scripts = {
+	lint: "eslint lib test",
+	"lint:fix": "npm run lint -- --fix",
+	unit: "istanbul test _mocha --reporter=spec test/index.js",
+	test: "npm run lint && npm run unit",
+	version: "grunt dist && git add dist/"
+};
+var repository = {
+	type: "git",
+	url: "git@github.com:indutny/elliptic"
+};
+var keywords = [
+	"EC",
+	"Elliptic",
+	"curve",
+	"Cryptography"
+];
+var author = "Fedor Indutny <fedor@indutny.com>";
+var license = "MIT";
+var bugs = {
+	url: "https://github.com/indutny/elliptic/issues"
+};
+var homepage = "https://github.com/indutny/elliptic";
+var devDependencies = {
+	brfs: "^2.0.2",
+	coveralls: "^3.1.0",
+	eslint: "^7.6.0",
+	grunt: "^1.2.1",
+	"grunt-browserify": "^5.3.0",
+	"grunt-cli": "^1.3.2",
+	"grunt-contrib-connect": "^3.0.0",
+	"grunt-contrib-copy": "^1.0.0",
+	"grunt-contrib-uglify": "^5.0.0",
+	"grunt-mocha-istanbul": "^5.0.2",
+	"grunt-saucelabs": "^9.0.1",
+	istanbul: "^0.4.5",
+	mocha: "^8.0.1"
+};
+var dependencies = {
+	"bn.js": "^4.11.9",
+	brorand: "^1.1.0",
+	"hash.js": "^1.0.0",
+	"hmac-drbg": "^1.0.1",
+	inherits: "^2.0.4",
+	"minimalistic-assert": "^1.0.1",
+	"minimalistic-crypto-utils": "^1.0.1"
+};
+var require$$0 = {
+	name: name,
+	version: version$1,
+	description: description,
+	main: main,
+	files: files,
+	scripts: scripts,
+	repository: repository,
+	keywords: keywords,
+	author: author,
+	license: license,
+	bugs: bugs,
+	homepage: homepage,
+	devDependencies: devDependencies,
+	dependencies: dependencies
+};
+
+var utils$o = {};
+
+var bn = {exports: {}};
+
+(function (module) {
+	(function (module, exports) {
+
+	  // Utils
+	  function assert (val, msg) {
+	    if (!val) throw new Error(msg || 'Assertion failed');
+	  }
+
+	  // Could use `inherits` module, but don't want to move from single file
+	  // architecture yet.
+	  function inherits (ctor, superCtor) {
+	    ctor.super_ = superCtor;
+	    var TempCtor = function () {};
+	    TempCtor.prototype = superCtor.prototype;
+	    ctor.prototype = new TempCtor();
+	    ctor.prototype.constructor = ctor;
+	  }
+
+	  // BN
+
+	  function BN (number, base, endian) {
+	    if (BN.isBN(number)) {
+	      return number;
+	    }
+
+	    this.negative = 0;
+	    this.words = null;
+	    this.length = 0;
+
+	    // Reduction context
+	    this.red = null;
+
+	    if (number !== null) {
+	      if (base === 'le' || base === 'be') {
+	        endian = base;
+	        base = 10;
+	      }
+
+	      this._init(number || 0, base || 10, endian || 'be');
+	    }
+	  }
+	  if (typeof module === 'object') {
+	    module.exports = BN;
+	  } else {
+	    exports.BN = BN;
+	  }
+
+	  BN.BN = BN;
+	  BN.wordSize = 26;
+
+	  var Buffer;
+	  try {
+	    if (typeof window !== 'undefined' && typeof window.Buffer !== 'undefined') {
+	      Buffer = window.Buffer;
+	    } else {
+	      Buffer = require$$3.Buffer;
+	    }
+	  } catch (e) {
+	  }
+
+	  BN.isBN = function isBN (num) {
+	    if (num instanceof BN) {
+	      return true;
+	    }
+
+	    return num !== null && typeof num === 'object' &&
+	      num.constructor.wordSize === BN.wordSize && Array.isArray(num.words);
+	  };
+
+	  BN.max = function max (left, right) {
+	    if (left.cmp(right) > 0) return left;
+	    return right;
+	  };
+
+	  BN.min = function min (left, right) {
+	    if (left.cmp(right) < 0) return left;
+	    return right;
+	  };
+
+	  BN.prototype._init = function init (number, base, endian) {
+	    if (typeof number === 'number') {
+	      return this._initNumber(number, base, endian);
+	    }
+
+	    if (typeof number === 'object') {
+	      return this._initArray(number, base, endian);
+	    }
+
+	    if (base === 'hex') {
+	      base = 16;
+	    }
+	    assert(base === (base | 0) && base >= 2 && base <= 36);
+
+	    number = number.toString().replace(/\s+/g, '');
+	    var start = 0;
+	    if (number[0] === '-') {
+	      start++;
+	      this.negative = 1;
+	    }
+
+	    if (start < number.length) {
+	      if (base === 16) {
 	        this._parseHex(number, start, endian);
 	      } else {
 	        this._parseBase(number, base, start);
@@ -16631,14 +16970,14 @@ var bn = {exports: {}};
 
 var bnExports = bn.exports;
 
-var minimalisticAssert = assert$g;
+var minimalisticAssert = assert$f;
 
-function assert$g(val, msg) {
+function assert$f(val, msg) {
   if (!val)
     throw new Error(msg || 'Assertion failed');
 }
 
-assert$g.equal = function assertEqual(l, r, msg) {
+assert$f.equal = function assertEqual(l, r, msg) {
   if (l != r)
     throw new Error(msg || ('Assertion failed: ' + l + ' != ' + r));
 };
@@ -16901,7 +17240,7 @@ var BN$8 = bnExports;
 var utils$m = utils$o;
 var getNAF = utils$m.getNAF;
 var getJSF = utils$m.getJSF;
-var assert$f = utils$m.assert;
+var assert$e = utils$m.assert;
 
 function BaseCurve(type, conf) {
   this.type = type;
@@ -16947,7 +17286,7 @@ BaseCurve.prototype.validate = function validate() {
 };
 
 BaseCurve.prototype._fixedNafMul = function _fixedNafMul(p, k) {
-  assert$f(p.precomputed);
+  assert$e(p.precomputed);
   var doubles = p._getDoubles();
 
   var naf = getNAF(k, 1, this._bitLength);
@@ -17004,7 +17343,7 @@ BaseCurve.prototype._wnafMul = function _wnafMul(p, k) {
     if (i < 0)
       break;
     var z = naf[i];
-    assert$f(z !== 0);
+    assert$e(z !== 0);
     if (p.type === 'affine') {
       // J +- P
       if (z > 0)
@@ -17172,9 +17511,9 @@ BaseCurve.prototype.decodePoint = function decodePoint(bytes, enc) {
   if ((bytes[0] === 0x04 || bytes[0] === 0x06 || bytes[0] === 0x07) &&
       bytes.length - 1 === 2 * len) {
     if (bytes[0] === 0x06)
-      assert$f(bytes[bytes.length - 1] % 2 === 0);
+      assert$e(bytes[bytes.length - 1] % 2 === 0);
     else if (bytes[0] === 0x07)
-      assert$f(bytes[bytes.length - 1] % 2 === 1);
+      assert$e(bytes[bytes.length - 1] % 2 === 1);
 
     var res =  this.point(bytes.slice(1, 1 + len),
       bytes.slice(1 + len, 1 + 2 * len));
@@ -17313,7 +17652,7 @@ var BN$7 = bnExports;
 var inherits$3 = inherits_browserExports;
 var Base$2 = base;
 
-var assert$e = utils$l.assert;
+var assert$d = utils$l.assert;
 
 function ShortCurve(conf) {
   Base$2.call(this, 'short', conf);
@@ -17358,7 +17697,7 @@ ShortCurve.prototype._getEndomorphism = function _getEndomorphism(conf) {
       lambda = lambdas[0];
     } else {
       lambda = lambdas[1];
-      assert$e(this.g.mul(lambda).x.cmp(this.g.x.redMul(beta)) === 0);
+      assert$d(this.g.mul(lambda).x.cmp(this.g.x.redMul(beta)) === 0);
     }
   }
 
@@ -18427,7 +18766,7 @@ var BN$5 = bnExports;
 var inherits$1 = inherits_browserExports;
 var Base = base;
 
-var assert$d = utils$j.assert;
+var assert$c = utils$j.assert;
 
 function EdwardsCurve(conf) {
   // NOTE: Important as we are creating point in Base.call()
@@ -18444,7 +18783,7 @@ function EdwardsCurve(conf) {
   this.d = new BN$5(conf.d, 16).toRed(this.red);
   this.dd = this.d.redAdd(this.d);
 
-  assert$d(!this.twisted || this.c.fromRed().cmpn(1) === 0);
+  assert$c(!this.twisted || this.c.fromRed().cmpn(1) === 0);
   this.oneC = (conf.c | 0) === 1;
 }
 inherits$1(EdwardsCurve, Base);
@@ -18872,7 +19211,7 @@ var hash$2 = {};
 
 var utils$i = {};
 
-var assert$c = minimalisticAssert;
+var assert$b = minimalisticAssert;
 var inherits = inherits_browserExports;
 
 utils$i.inherits = inherits;
@@ -18993,7 +19332,7 @@ utils$i.zero8 = zero8;
 
 function join32(msg, start, end, endian) {
   var len = end - start;
-  assert$c(len % 4 === 0);
+  assert$b(len % 4 === 0);
   var res = new Array(len / 4);
   for (var i = 0, k = start; i < res.length; i++, k += 4) {
     var w;
@@ -19152,7 +19491,7 @@ utils$i.shr64_lo = shr64_lo$1;
 var common$5 = {};
 
 var utils$h = utils$i;
-var assert$b = minimalisticAssert;
+var assert$a = minimalisticAssert;
 
 function BlockHash$4() {
   this.pending = null;
@@ -19197,7 +19536,7 @@ BlockHash$4.prototype.update = function update(msg, enc) {
 
 BlockHash$4.prototype.digest = function digest(enc) {
   this.update(this._pad());
-  assert$b(this.pending === null);
+  assert$a(this.pending === null);
 
   return this._digest(enc);
 };
@@ -19370,7 +19709,7 @@ SHA1.prototype._digest = function digest(enc) {
 var utils$e = utils$i;
 var common$2 = common$5;
 var shaCommon = common$4;
-var assert$a = minimalisticAssert;
+var assert$9 = minimalisticAssert;
 
 var sum32$1 = utils$e.sum32;
 var sum32_4$1 = utils$e.sum32_4;
@@ -19440,7 +19779,7 @@ SHA256$1.prototype._update = function _update(msg, start) {
   var g = this.h[6];
   var h = this.h[7];
 
-  assert$a(this.k.length === W.length);
+  assert$9(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$1(s0_256(a), maj32(a, b, c));
@@ -19501,7 +19840,7 @@ SHA224.prototype._digest = function digest(enc) {
 
 var utils$c = utils$i;
 var common$1 = common$5;
-var assert$9 = minimalisticAssert;
+var assert$8 = minimalisticAssert;
 
 var rotr64_hi = utils$c.rotr64_hi;
 var rotr64_lo = utils$c.rotr64_lo;
@@ -19636,7 +19975,7 @@ SHA512$1.prototype._update = function _update(msg, start) {
   var hh = this.h[14];
   var hl = this.h[15];
 
-  assert$9(this.k.length === W.length);
+  assert$8(this.k.length === W.length);
   for (var i = 0; i < W.length; i += 2) {
     var c0_hi = hh;
     var c0_lo = hl;
@@ -20016,7 +20355,7 @@ var sh = [
 ];
 
 var utils$9 = utils$i;
-var assert$8 = minimalisticAssert;
+var assert$7 = minimalisticAssert;
 
 function Hmac(hash, key, enc) {
   if (!(this instanceof Hmac))
@@ -20035,7 +20374,7 @@ Hmac.prototype._init = function init(key) {
   // Shorten key, if needed
   if (key.length > this.blockSize)
     key = new this.Hash().update(key).digest();
-  assert$8(key.length <= this.blockSize);
+  assert$7(key.length <= this.blockSize);
 
   // Add padding to key
   for (var i = key.length; i < this.blockSize; i++)
@@ -21078,7 +21417,7 @@ function requireSecp256k1 () {
 
 var hash$1 = hash$2;
 var utils$8 = utils$n;
-var assert$7 = minimalisticAssert;
+var assert$6 = minimalisticAssert;
 
 function HmacDRBG$1(options) {
   if (!(this instanceof HmacDRBG$1))
@@ -21097,7 +21436,7 @@ function HmacDRBG$1(options) {
   var entropy = utils$8.toArray(options.entropy, options.entropyEnc || 'hex');
   var nonce = utils$8.toArray(options.nonce, options.nonceEnc || 'hex');
   var pers = utils$8.toArray(options.pers, options.persEnc || 'hex');
-  assert$7(entropy.length >= (this.minEntropy / 8),
+  assert$6(entropy.length >= (this.minEntropy / 8),
          'Not enough entropy. Minimum is: ' + this.minEntropy + ' bits');
   this._init(entropy, nonce, pers);
 }
@@ -21152,7 +21491,7 @@ HmacDRBG$1.prototype.reseed = function reseed(entropy, entropyEnc, add, addEnc)
   entropy = utils$8.toArray(entropy, entropyEnc);
   add = utils$8.toArray(add, addEnc);
 
-  assert$7(entropy.length >= (this.minEntropy / 8),
+  assert$6(entropy.length >= (this.minEntropy / 8),
          'Not enough entropy. Minimum is: ' + this.minEntropy + ' bits');
 
   this._update(entropy.concat(add || []));
@@ -21190,7 +21529,7 @@ HmacDRBG$1.prototype.generate = function generate(len, enc, add, addEnc) {
 
 var BN$4 = bnExports;
 var utils$7 = utils$o;
-var assert$6 = utils$7.assert;
+var assert$5 = utils$7.assert;
 
 function KeyPair$3(ec, options) {
   this.ec = ec;
@@ -21275,10 +21614,10 @@ KeyPair$3.prototype._importPublic = function _importPublic(key, enc) {
     // Weierstrass/Edwards points on the other hand have both `x` and
     // `y` coordinates.
     if (this.ec.curve.type === 'mont') {
-      assert$6(key.x, 'Need x coordinate');
+      assert$5(key.x, 'Need x coordinate');
     } else if (this.ec.curve.type === 'short' ||
                this.ec.curve.type === 'edwards') {
-      assert$6(key.x && key.y, 'Need both x and y coordinate');
+      assert$5(key.x && key.y, 'Need both x and y coordinate');
     }
     this.pub = this.ec.curve.point(key.x, key.y);
     return;
@@ -21289,7 +21628,7 @@ KeyPair$3.prototype._importPublic = function _importPublic(key, enc) {
 // ECDH
 KeyPair$3.prototype.derive = function derive(pub) {
   if(!pub.validate()) {
-    assert$6(pub.validate(), 'public point not validated');
+    assert$5(pub.validate(), 'public point not validated');
   }
   return pub.mul(this.priv).getX();
 };
@@ -21311,7 +21650,7 @@ KeyPair$3.prototype.inspect = function inspect() {
 var BN$3 = bnExports;
 
 var utils$6 = utils$o;
-var assert$5 = utils$6.assert;
+var assert$4 = utils$6.assert;
 
 function Signature$3(options, enc) {
   if (options instanceof Signature$3)
@@ -21320,7 +21659,7 @@ function Signature$3(options, enc) {
   if (this._importDER(options, enc))
     return;
 
-  assert$5(options.r && options.s, 'Signature without r or s');
+  assert$4(options.r && options.s, 'Signature without r or s');
   this.r = new BN$3(options.r, 16);
   this.s = new BN$3(options.s, 16);
   if (options.recoveryParam === undefined)
@@ -21478,7 +21817,7 @@ var HmacDRBG = hmacDrbg;
 var utils$5 = utils$o;
 var curves$1 = curves$2;
 var rand = brorandExports;
-var assert$4 = utils$5.assert;
+var assert$3 = utils$5.assert;
 
 var KeyPair$2 = key$1;
 var Signature$2 = signature$1;
@@ -21489,7 +21828,7 @@ function EC$1(options) {
 
   // Shortcut `elliptic.ec(curve-name)`
   if (typeof options === 'string') {
-    assert$4(Object.prototype.hasOwnProperty.call(curves$1, options),
+    assert$3(Object.prototype.hasOwnProperty.call(curves$1, options),
       'Unknown curve ' + options);
 
     options = curves$1[options];
@@ -21667,7 +22006,7 @@ EC$1.prototype.verify = function verify(msg, signature, key, enc) {
 };
 
 EC$1.prototype.recoverPubKey = function(msg, signature, j, enc) {
-  assert$4((3 & j) === j, 'The recovery param is more than two bits');
+  assert$3((3 & j) === j, 'The recovery param is more than two bits');
   signature = new Signature$2(signature, enc);
 
   var n = this.n;
@@ -21716,7 +22055,7 @@ EC$1.prototype.getKeyRecoveryParam = function(e, signature, Q, enc) {
 };
 
 var utils$4 = utils$o;
-var assert$3 = utils$4.assert;
+var assert$2 = utils$4.assert;
 var parseBytes$2 = utils$4.parseBytes;
 var cachedProperty$1 = utils$4.cachedProperty;
 
@@ -21790,7 +22129,7 @@ cachedProperty$1(KeyPair$1, 'messagePrefix', function messagePrefix() {
 });
 
 KeyPair$1.prototype.sign = function sign(message) {
-  assert$3(this._secret, 'KeyPair can only verify');
+  assert$2(this._secret, 'KeyPair can only verify');
   return this.eddsa.sign(message, this);
 };
 
@@ -21799,7 +22138,7 @@ KeyPair$1.prototype.verify = function verify(message, sig) {
 };
 
 KeyPair$1.prototype.getSecret = function getSecret(enc) {
-  assert$3(this._secret, 'KeyPair is public only');
+  assert$2(this._secret, 'KeyPair is public only');
   return utils$4.encode(this.secret(), enc);
 };
 
@@ -21811,7 +22150,7 @@ var key = KeyPair$1;
 
 var BN$1 = bnExports;
 var utils$3 = utils$o;
-var assert$2 = utils$3.assert;
+var assert$1 = utils$3.assert;
 var cachedProperty = utils$3.cachedProperty;
 var parseBytes$1 = utils$3.parseBytes;
 
@@ -21836,7 +22175,7 @@ function Signature$1(eddsa, sig) {
     };
   }
 
-  assert$2(sig.R && sig.S, 'Signature without R or S');
+  assert$1(sig.R && sig.S, 'Signature without R or S');
 
   if (eddsa.isPoint(sig.R))
     this._R = sig.R;
@@ -21876,13 +22215,13 @@ var signature = Signature$1;
 var hash = hash$2;
 var curves = curves$2;
 var utils$2 = utils$o;
-var assert$1 = utils$2.assert;
+var assert = utils$2.assert;
 var parseBytes = utils$2.parseBytes;
 var KeyPair = key;
 var Signature = signature;
 
 function EDDSA(curve) {
-  assert$1(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);
@@ -22301,447 +22640,110 @@ var elliptic$1 = {
     if (s.cmp(ecparams.n) >= 0) s = new BN(0);
 
     output.set(r.toArrayLike(Uint8Array, 'be', 32), 0);
-    output.set(s.toArrayLike(Uint8Array, 'be', 32), 32);
-
-    return 0
-  },
-
-  ecdsaSign (obj, message, seckey, data, noncefn) {
-    if (noncefn) {
-      const _noncefn = noncefn;
-      noncefn = (counter) => {
-        const nonce = _noncefn(message, seckey, null, data, counter);
-
-        const isValid = nonce instanceof Uint8Array && nonce.length === 32;
-        if (!isValid) throw new Error('This is the way')
-
-        return new BN(nonce)
-      };
-    }
-
-    const d = new BN(seckey);
-    if (d.cmp(ecparams.n) >= 0 || d.isZero()) return 1
-
-    let sig;
-    try {
-      sig = ec.sign(message, seckey, { canonical: true, k: noncefn, pers: data });
-    } catch (err) {
-      return 1
-    }
-
-    obj.signature.set(sig.r.toArrayLike(Uint8Array, 'be', 32), 0);
-    obj.signature.set(sig.s.toArrayLike(Uint8Array, 'be', 32), 32);
-    obj.recid = sig.recoveryParam;
-
-    return 0
-  },
-
-  ecdsaVerify (sig, msg32, pubkey) {
-    const sigObj = { r: sig.subarray(0, 32), s: sig.subarray(32, 64) };
-
-    const sigr = new BN(sigObj.r);
-    const sigs = new BN(sigObj.s);
-    if (sigr.cmp(ecparams.n) >= 0 || sigs.cmp(ecparams.n) >= 0) return 1
-    if (sigs.cmp(ec.nh) === 1 || sigr.isZero() || sigs.isZero()) return 3
-
-    const pair = loadPublicKey(pubkey);
-    if (pair === null) return 2
-
-    const point = pair.getPublic();
-    const isValid = ec.verify(msg32, sigObj, point);
-    return isValid ? 0 : 3
-  },
-
-  ecdsaRecover (output, sig, recid, msg32) {
-    const sigObj = { r: sig.slice(0, 32), s: sig.slice(32, 64) };
-
-    const sigr = new BN(sigObj.r);
-    const sigs = new BN(sigObj.s);
-    if (sigr.cmp(ecparams.n) >= 0 || sigs.cmp(ecparams.n) >= 0) return 1
-
-    if (sigr.isZero() || sigs.isZero()) return 2
-
-    // Can throw `throw new Error('Unable to find sencond key candinate');`
-    let point;
-    try {
-      point = ec.recoverPubKey(msg32, sigObj, recid);
-    } catch (err) {
-      return 2
-    }
-
-    savePublicKey(output, point);
-
-    return 0
-  },
-
-  ecdh (output, pubkey, seckey, data, hashfn, xbuf, ybuf) {
-    const pair = loadPublicKey(pubkey);
-    if (pair === null) return 1
-
-    const scalar = new BN(seckey);
-    if (scalar.cmp(ecparams.n) >= 0 || scalar.isZero()) return 2
-
-    const point = pair.getPublic().mul(scalar);
-
-    if (hashfn === undefined) {
-      const data = point.encode(null, true);
-      const sha256 = ec.hash().update(data).digest();
-      for (let i = 0; i < 32; ++i) output[i] = sha256[i];
-    } else {
-      if (!xbuf) xbuf = new Uint8Array(32);
-      const x = point.getX().toArray('be', 32);
-      for (let i = 0; i < 32; ++i) xbuf[i] = x[i];
-
-      if (!ybuf) ybuf = new Uint8Array(32);
-      const y = point.getY().toArray('be', 32);
-      for (let i = 0; i < 32; ++i) ybuf[i] = y[i];
-
-      const hash = hashfn(xbuf, ybuf, data);
-
-      const isValid = hash instanceof Uint8Array && hash.length === output.length;
-      if (!isValid) return 2
-
-      output.set(hash);
-    }
-
-    return 0
-  }
-};
-
-const errors = {
-  IMPOSSIBLE_CASE: 'Impossible case. Please create issue.',
-  TWEAK_ADD:
-    'The tweak was out of range or the resulted private key is invalid',
-  TWEAK_MUL: 'The tweak was out of range or equal to zero',
-  CONTEXT_RANDOMIZE_UNKNOW: 'Unknow error on context randomization',
-  SECKEY_INVALID: 'Private Key is invalid',
-  PUBKEY_PARSE: 'Public Key could not be parsed',
-  PUBKEY_SERIALIZE: 'Public Key serialization error',
-  PUBKEY_COMBINE: 'The sum of the public keys is not valid',
-  SIG_PARSE: 'Signature could not be parsed',
-  SIGN: 'The nonce generation function failed, or the private key was invalid',
-  RECOVER: 'Public key could not be recover',
-  ECDH: 'Scalar was invalid (zero or overflow)'
-};
-
-function assert (cond, msg) {
-  if (!cond) throw new Error(msg)
-}
-
-function isUint8Array (name, value, length) {
-  assert(value instanceof Uint8Array, `Expected ${name} to be an Uint8Array`);
-
-  if (length !== undefined) {
-    if (Array.isArray(length)) {
-      const numbers = length.join(', ');
-      const msg = `Expected ${name} to be an Uint8Array with length [${numbers}]`;
-      assert(length.includes(value.length), msg);
-    } else {
-      const msg = `Expected ${name} to be an Uint8Array with length ${length}`;
-      assert(value.length === length, msg);
-    }
-  }
-}
-
-function isCompressed (value) {
-  assert(toTypeString(value) === 'Boolean', 'Expected compressed to be a Boolean');
-}
-
-function getAssertedOutput (output = (len) => new Uint8Array(len), length) {
-  if (typeof output === 'function') output = output(length);
-  isUint8Array('output', output, length);
-  return output
-}
-
-function toTypeString (value) {
-  return Object.prototype.toString.call(value).slice(8, -1)
-}
-
-var lib = (secp256k1) => {
-  return {
-    contextRandomize (seed) {
-      assert(
-        seed === null || seed instanceof Uint8Array,
-        'Expected seed to be an Uint8Array or null'
-      );
-      if (seed !== null) isUint8Array('seed', seed, 32);
-
-      switch (secp256k1.contextRandomize(seed)) {
-        case 1:
-          throw new Error(errors.CONTEXT_RANDOMIZE_UNKNOW)
-      }
-    },
-
-    privateKeyVerify (seckey) {
-      isUint8Array('private key', seckey, 32);
-
-      return secp256k1.privateKeyVerify(seckey) === 0
-    },
-
-    privateKeyNegate (seckey) {
-      isUint8Array('private key', seckey, 32);
-
-      switch (secp256k1.privateKeyNegate(seckey)) {
-        case 0:
-          return seckey
-        case 1:
-          throw new Error(errors.IMPOSSIBLE_CASE)
-      }
-    },
-
-    privateKeyTweakAdd (seckey, tweak) {
-      isUint8Array('private key', seckey, 32);
-      isUint8Array('tweak', tweak, 32);
-
-      switch (secp256k1.privateKeyTweakAdd(seckey, tweak)) {
-        case 0:
-          return seckey
-        case 1:
-          throw new Error(errors.TWEAK_ADD)
-      }
-    },
-
-    privateKeyTweakMul (seckey, tweak) {
-      isUint8Array('private key', seckey, 32);
-      isUint8Array('tweak', tweak, 32);
-
-      switch (secp256k1.privateKeyTweakMul(seckey, tweak)) {
-        case 0:
-          return seckey
-        case 1:
-          throw new Error(errors.TWEAK_MUL)
-      }
-    },
-
-    publicKeyVerify (pubkey) {
-      isUint8Array('public key', pubkey, [33, 65]);
-
-      return secp256k1.publicKeyVerify(pubkey) === 0
-    },
-
-    publicKeyCreate (seckey, compressed = true, output) {
-      isUint8Array('private key', seckey, 32);
-      isCompressed(compressed);
-      output = getAssertedOutput(output, compressed ? 33 : 65);
-
-      switch (secp256k1.publicKeyCreate(output, seckey)) {
-        case 0:
-          return output
-        case 1:
-          throw new Error(errors.SECKEY_INVALID)
-        case 2:
-          throw new Error(errors.PUBKEY_SERIALIZE)
-      }
-    },
+    output.set(s.toArrayLike(Uint8Array, 'be', 32), 32);
 
-    publicKeyConvert (pubkey, compressed = true, output) {
-      isUint8Array('public key', pubkey, [33, 65]);
-      isCompressed(compressed);
-      output = getAssertedOutput(output, compressed ? 33 : 65);
+    return 0
+  },
 
-      switch (secp256k1.publicKeyConvert(output, pubkey)) {
-        case 0:
-          return output
-        case 1:
-          throw new Error(errors.PUBKEY_PARSE)
-        case 2:
-          throw new Error(errors.PUBKEY_SERIALIZE)
-      }
-    },
+  ecdsaSign (obj, message, seckey, data, noncefn) {
+    if (noncefn) {
+      const _noncefn = noncefn;
+      noncefn = (counter) => {
+        const nonce = _noncefn(message, seckey, null, data, counter);
 
-    publicKeyNegate (pubkey, compressed = true, output) {
-      isUint8Array('public key', pubkey, [33, 65]);
-      isCompressed(compressed);
-      output = getAssertedOutput(output, compressed ? 33 : 65);
+        const isValid = nonce instanceof Uint8Array && nonce.length === 32;
+        if (!isValid) throw new Error('This is the way')
 
-      switch (secp256k1.publicKeyNegate(output, pubkey)) {
-        case 0:
-          return output
-        case 1:
-          throw new Error(errors.PUBKEY_PARSE)
-        case 2:
-          throw new Error(errors.IMPOSSIBLE_CASE)
-        case 3:
-          throw new Error(errors.PUBKEY_SERIALIZE)
-      }
-    },
+        return new BN(nonce)
+      };
+    }
 
-    publicKeyCombine (pubkeys, compressed = true, output) {
-      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]);
-      }
-      isCompressed(compressed);
-      output = getAssertedOutput(output, compressed ? 33 : 65);
+    const d = new BN(seckey);
+    if (d.cmp(ecparams.n) >= 0 || d.isZero()) return 1
 
-      switch (secp256k1.publicKeyCombine(output, pubkeys)) {
-        case 0:
-          return output
-        case 1:
-          throw new Error(errors.PUBKEY_PARSE)
-        case 2:
-          throw new Error(errors.PUBKEY_COMBINE)
-        case 3:
-          throw new Error(errors.PUBKEY_SERIALIZE)
-      }
-    },
+    let sig;
+    try {
+      sig = ec.sign(message, seckey, { canonical: true, k: noncefn, pers: data });
+    } catch (err) {
+      return 1
+    }
 
-    publicKeyTweakAdd (pubkey, tweak, compressed = true, output) {
-      isUint8Array('public key', pubkey, [33, 65]);
-      isUint8Array('tweak', tweak, 32);
-      isCompressed(compressed);
-      output = getAssertedOutput(output, compressed ? 33 : 65);
+    obj.signature.set(sig.r.toArrayLike(Uint8Array, 'be', 32), 0);
+    obj.signature.set(sig.s.toArrayLike(Uint8Array, 'be', 32), 32);
+    obj.recid = sig.recoveryParam;
 
-      switch (secp256k1.publicKeyTweakAdd(output, pubkey, tweak)) {
-        case 0:
-          return output
-        case 1:
-          throw new Error(errors.PUBKEY_PARSE)
-        case 2:
-          throw new Error(errors.TWEAK_ADD)
-      }
-    },
+    return 0
+  },
 
-    publicKeyTweakMul (pubkey, tweak, compressed = true, output) {
-      isUint8Array('public key', pubkey, [33, 65]);
-      isUint8Array('tweak', tweak, 32);
-      isCompressed(compressed);
-      output = getAssertedOutput(output, compressed ? 33 : 65);
+  ecdsaVerify (sig, msg32, pubkey) {
+    const sigObj = { r: sig.subarray(0, 32), s: sig.subarray(32, 64) };
 
-      switch (secp256k1.publicKeyTweakMul(output, pubkey, tweak)) {
-        case 0:
-          return output
-        case 1:
-          throw new Error(errors.PUBKEY_PARSE)
-        case 2:
-          throw new Error(errors.TWEAK_MUL)
-      }
-    },
+    const sigr = new BN(sigObj.r);
+    const sigs = new BN(sigObj.s);
+    if (sigr.cmp(ecparams.n) >= 0 || sigs.cmp(ecparams.n) >= 0) return 1
+    if (sigs.cmp(ec.nh) === 1 || sigr.isZero() || sigs.isZero()) return 3
 
-    signatureNormalize (sig) {
-      isUint8Array('signature', sig, 64);
+    const pair = loadPublicKey(pubkey);
+    if (pair === null) return 2
 
-      switch (secp256k1.signatureNormalize(sig)) {
-        case 0:
-          return sig
-        case 1:
-          throw new Error(errors.SIG_PARSE)
-      }
-    },
+    const point = pair.getPublic();
+    const isValid = ec.verify(msg32, sigObj, point);
+    return isValid ? 0 : 3
+  },
 
-    signatureExport (sig, output) {
-      isUint8Array('signature', sig, 64);
-      output = getAssertedOutput(output, 72);
+  ecdsaRecover (output, sig, recid, msg32) {
+    const sigObj = { r: sig.slice(0, 32), s: sig.slice(32, 64) };
 
-      const obj = { output, outputlen: 72 };
-      switch (secp256k1.signatureExport(obj, sig)) {
-        case 0:
-          return output.slice(0, obj.outputlen)
-        case 1:
-          throw new Error(errors.SIG_PARSE)
-        case 2:
-          throw new Error(errors.IMPOSSIBLE_CASE)
-      }
-    },
+    const sigr = new BN(sigObj.r);
+    const sigs = new BN(sigObj.s);
+    if (sigr.cmp(ecparams.n) >= 0 || sigs.cmp(ecparams.n) >= 0) return 1
 
-    signatureImport (sig, output) {
-      isUint8Array('signature', sig);
-      output = getAssertedOutput(output, 64);
+    if (sigr.isZero() || sigs.isZero()) return 2
 
-      switch (secp256k1.signatureImport(output, sig)) {
-        case 0:
-          return output
-        case 1:
-          throw new Error(errors.SIG_PARSE)
-        case 2:
-          throw new Error(errors.IMPOSSIBLE_CASE)
-      }
-    },
+    // Can throw `throw new Error('Unable to find sencond key candinate');`
+    let point;
+    try {
+      point = ec.recoverPubKey(msg32, sigObj, recid);
+    } catch (err) {
+      return 2
+    }
 
-    ecdsaSign (msg32, seckey, options = {}, output) {
-      isUint8Array('message', msg32, 32);
-      isUint8Array('private key', seckey, 32);
-      assert(toTypeString(options) === 'Object', 'Expected options to be an Object');
-      if (options.data !== undefined) isUint8Array('options.data', options.data);
-      if (options.noncefn !== undefined) assert(toTypeString(options.noncefn) === 'Function', 'Expected options.noncefn to be a Function');
-      output = getAssertedOutput(output, 64);
+    savePublicKey(output, point);
 
-      const obj = { signature: output, recid: null };
-      switch (secp256k1.ecdsaSign(obj, msg32, seckey, options.data, options.noncefn)) {
-        case 0:
-          return obj
-        case 1:
-          throw new Error(errors.SIGN)
-        case 2:
-          throw new Error(errors.IMPOSSIBLE_CASE)
-      }
-    },
+    return 0
+  },
 
-    ecdsaVerify (sig, msg32, pubkey) {
-      isUint8Array('signature', sig, 64);
-      isUint8Array('message', msg32, 32);
-      isUint8Array('public key', pubkey, [33, 65]);
+  ecdh (output, pubkey, seckey, data, hashfn, xbuf, ybuf) {
+    const pair = loadPublicKey(pubkey);
+    if (pair === null) return 1
 
-      switch (secp256k1.ecdsaVerify(sig, msg32, pubkey)) {
-        case 0:
-          return true
-        case 3:
-          return false
-        case 1:
-          throw new Error(errors.SIG_PARSE)
-        case 2:
-          throw new Error(errors.PUBKEY_PARSE)
-      }
-    },
+    const scalar = new BN(seckey);
+    if (scalar.cmp(ecparams.n) >= 0 || scalar.isZero()) return 2
 
-    ecdsaRecover (sig, recid, msg32, compressed = true, output) {
-      isUint8Array('signature', sig, 64);
-      assert(
-        toTypeString(recid) === 'Number' &&
-          recid >= 0 &&
-          recid <= 3,
-        'Expected recovery id to be a Number within interval [0, 3]'
-      );
-      isUint8Array('message', msg32, 32);
-      isCompressed(compressed);
-      output = getAssertedOutput(output, compressed ? 33 : 65);
+    const point = pair.getPublic().mul(scalar);
 
-      switch (secp256k1.ecdsaRecover(output, sig, recid, msg32)) {
-        case 0:
-          return output
-        case 1:
-          throw new Error(errors.SIG_PARSE)
-        case 2:
-          throw new Error(errors.RECOVER)
-        case 3:
-          throw new Error(errors.IMPOSSIBLE_CASE)
-      }
-    },
+    if (hashfn === undefined) {
+      const data = point.encode(null, true);
+      const sha256 = ec.hash().update(data).digest();
+      for (let i = 0; i < 32; ++i) output[i] = sha256[i];
+    } else {
+      if (!xbuf) xbuf = new Uint8Array(32);
+      const x = point.getX().toArray('be', 32);
+      for (let i = 0; i < 32; ++i) xbuf[i] = x[i];
 
-    ecdh (pubkey, seckey, options = {}, output) {
-      isUint8Array('public key', pubkey, [33, 65]);
-      isUint8Array('private key', seckey, 32);
-      assert(toTypeString(options) === 'Object', 'Expected options to be an Object');
-      if (options.data !== undefined) isUint8Array('options.data', options.data);
-      if (options.hashfn !== undefined) {
-        assert(toTypeString(options.hashfn) === 'Function', 'Expected options.hashfn to be a Function');
-        if (options.xbuf !== undefined) isUint8Array('options.xbuf', options.xbuf, 32);
-        if (options.ybuf !== undefined) isUint8Array('options.ybuf', options.ybuf, 32);
-        isUint8Array('output', output);
-      } else {
-        output = getAssertedOutput(output, 32);
-      }
+      if (!ybuf) ybuf = new Uint8Array(32);
+      const y = point.getY().toArray('be', 32);
+      for (let i = 0; i < 32; ++i) ybuf[i] = y[i];
 
-      switch (secp256k1.ecdh(output, pubkey, seckey, options.data, options.hashfn, options.xbuf, options.ybuf)) {
-        case 0:
-          return output
-        case 1:
-          throw new Error(errors.PUBKEY_PARSE)
-        case 2:
-          throw new Error(errors.ECDH)
-      }
+      const hash = hashfn(xbuf, ybuf, data);
+
+      const isValid = hash instanceof Uint8Array && hash.length === output.length;
+      if (!isValid) return 2
+
+      output.set(hash);
     }
+
+    return 0
   }
 };
 
@@ -27196,7 +27198,7 @@ class Identity {
             this.selectedAccount = new TextDecoder().decode(selected);
         }
         else {
-            const importee = await import(/* webpackChunkName: "generate-account" */ './index-ub31QSed-EMPr2oeb.js');
+            const importee = await import(/* webpackChunkName: "generate-account" */ './index-G74WLzL7-tmiSHjUc.js');
             const { identity, accounts } = await importee.default(password, this.network);
             await globalThis.accountStore.put('public', JSON.stringify({ walletId: identity.walletId }));
             await globalThis.walletStore.put('version', String(1));
@@ -27388,7 +27390,7 @@ class Peernet {
         this.root = options.root;
         const { RequestMessage, ResponseMessage, PeerMessage, PeerMessageResponse, PeernetMessage, DHTMessage, DHTMessageResponse, DataMessage, DataMessageResponse, PsMessage, ChatMessage, PeernetFile
         // FolderMessageResponse
-         } = await import(/* webpackChunkName: "messages" */ './messages-guyZfse6-JeAlT5Nb.js');
+         } = await import(/* webpackChunkName: "messages" */ './messages-lWRTai7t-Bc6ghkkt.js');
         /**
          * proto Object containing protos
          * @type {Object}
@@ -27482,7 +27484,7 @@ class Peernet {
         if (this.#starting || this.#started)
             return;
         this.#starting = true;
-        const importee = await import('./client-UOCjJBGl-pbv-pTHd.js');
+        const importee = await import('./client-A009z8av-uBa1w1TW.js');
         /**
          * @access public
          * @type {PeernetClient}