@leofcoin/peernet 1.1.73 → 1.1.74

package/exports/browser/{peernet-0298b289.js → peernet-w0f2V8kl.js}

@@ -1,12 +1,29 @@
-import { K as KeyPath, a as KeyValue } from './value-4e80eeeb.js';
+import { K as KeyPath, a as KeyValue } from './value-wzPYMxsX.js';
 
 if (!globalThis.DEBUG) {
-  if (globalThis.localStorage) globalThis.DEBUG = Boolean(globalThis.localStorage.getItem('DEBUG') === 'true');
+  let DEBUG = [];
+  if (globalThis.localStorage) {
+    DEBUG = globalThis.localStorage.getItem('DEBUG');
+    globalThis.DEBUG = DEBUG ? DEBUG.split(',') : [DEBUG];
+  }
 }
 
-globalThis.debug = text => {
-  if (globalThis.DEBUG) console.log('\x1b[34m\x1b[1m%s', text, '\x1b[0m'); // bright blue
-};
+if (!globalThis.debug) {
+  globalThis.debug = (target, text) => {
+    if (!globalThis.DEBUG && globalThis.DEBUG.length === 0) return;
+    if (
+      globalThis.DEBUG.indexOf(target) !== -1 ||
+      globalThis.DEBUG.indexOf('*') !== -1 ||
+      globalThis.DEBUG === 'true' ||
+      globalThis.DEBUG === true
+    )
+      if (text)
+        console.log('\x1b[34m\x1b[1m%s', `${target}: ${text}`, '\x1b[0m');
+      else console.log('\x1b[34m\x1b[1m%s', `${target}`, '\x1b[0m');
+  };
+  globalThis.createDebugger = (target) => (text) =>
+    globalThis.debug(target, text);
+}
 
 class LittlePubSub {
     subscribers = {};
@@ -669,10 +686,7 @@ function getAugmentedNamespace(n) {
 	if (typeof f == "function") {
 		var a = function a () {
 			if (this instanceof a) {
-				var args = [null];
-				args.push.apply(args, arguments);
-				var Ctor = Function.bind.apply(f, args);
-				return new Ctor();
+        return Reflect.construct(f, arguments, this.constructor);
 			}
 			return f.apply(this, arguments);
 		};
@@ -12751,7 +12765,7 @@ const nothingFoundError = (hash) => {
   return new Error(`nothing found for ${hash}`)
 };
 
-const isBrowser = globalThis.navigator ? true : false;
+const isBrowser = globalThis.process?.versions?.node ? false : true;
 let LeofcoinStorage$1 = class LeofcoinStorage {
     name;
     root;
@@ -13000,514 +13014,177 @@ var index$1 = {
     }
 };
 
-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 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
 };
 
-function assert$g (cond, msg) {
-  if (!cond) throw new Error(msg)
-}
+var utils$o = {};
 
-function isUint8Array (name, value, length) {
-  assert$g(value instanceof Uint8Array, `Expected ${name} to be an Uint8Array`);
+var bn = {exports: {}};
 
-  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);
-    }
-  }
-}
+bn.exports;
 
-function isCompressed (value) {
-  assert$g(toTypeString(value) === 'Boolean', 'Expected compressed to be a Boolean');
-}
+(function (module) {
+	(function (module, exports) {
 
-function getAssertedOutput (output = (len) => new Uint8Array(len), length) {
-  if (typeof output === 'function') output = output(length);
-  isUint8Array('output', output, length);
-  return output
-}
+	  // Utils
+	  function assert (val, msg) {
+	    if (!val) throw new Error(msg || 'Assertion failed');
+	  }
 
-function toTypeString (value) {
-  return Object.prototype.toString.call(value).slice(8, -1)
-}
+	  // 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;
+	  }
 
-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);
+	  // BN
 
-      switch (secp256k1.contextRandomize(seed)) {
-        case 1:
-          throw new Error(errors.CONTEXT_RANDOMIZE_UNKNOW)
-      }
-    },
+	  function BN (number, base, endian) {
+	    if (BN.isBN(number)) {
+	      return number;
+	    }
 
-    privateKeyVerify (seckey) {
-      isUint8Array('private key', seckey, 32);
+	    this.negative = 0;
+	    this.words = null;
+	    this.length = 0;
 
-      return secp256k1.privateKeyVerify(seckey) === 0
-    },
+	    // Reduction context
+	    this.red = null;
 
-    privateKeyNegate (seckey) {
-      isUint8Array('private key', seckey, 32);
+	    if (number !== null) {
+	      if (base === 'le' || base === 'be') {
+	        endian = base;
+	        base = 10;
+	      }
 
-      switch (secp256k1.privateKeyNegate(seckey)) {
-        case 0:
-          return seckey
-        case 1:
-          throw new Error(errors.IMPOSSIBLE_CASE)
-      }
-    },
+	      this._init(number || 0, base || 10, endian || 'be');
+	    }
+	  }
+	  if (typeof module === 'object') {
+	    module.exports = BN;
+	  } else {
+	    exports.BN = BN;
+	  }
 
-    privateKeyTweakAdd (seckey, tweak) {
-      isUint8Array('private key', seckey, 32);
-      isUint8Array('tweak', tweak, 32);
+	  BN.BN = BN;
+	  BN.wordSize = 26;
 
-      switch (secp256k1.privateKeyTweakAdd(seckey, tweak)) {
-        case 0:
-          return seckey
-        case 1:
-          throw new Error(errors.TWEAK_ADD)
-      }
-    },
+	  var Buffer;
+	  try {
+	    if (typeof window !== 'undefined' && typeof window.Buffer !== 'undefined') {
+	      Buffer = window.Buffer;
+	    } else {
+	      Buffer = require$$3.Buffer;
+	    }
+	  } catch (e) {
+	  }
 
-    privateKeyTweakMul (seckey, tweak) {
-      isUint8Array('private key', seckey, 32);
-      isUint8Array('tweak', tweak, 32);
+	  BN.isBN = function isBN (num) {
+	    if (num instanceof BN) {
+	      return true;
+	    }
 
-      switch (secp256k1.privateKeyTweakMul(seckey, tweak)) {
-        case 0:
-          return seckey
-        case 1:
-          throw new Error(errors.TWEAK_MUL)
-      }
-    },
+	    return num !== null && typeof num === 'object' &&
+	      num.constructor.wordSize === BN.wordSize && Array.isArray(num.words);
+	  };
 
-    publicKeyVerify (pubkey) {
-      isUint8Array('public key', pubkey, [33, 65]);
+	  BN.max = function max (left, right) {
+	    if (left.cmp(right) > 0) return left;
+	    return right;
+	  };
 
-      return secp256k1.publicKeyVerify(pubkey) === 0
-    },
+	  BN.min = function min (left, right) {
+	    if (left.cmp(right) < 0) return left;
+	    return right;
+	  };
 
-    publicKeyCreate (seckey, compressed = true, output) {
-      isUint8Array('private key', seckey, 32);
-      isCompressed(compressed);
-      output = getAssertedOutput(output, compressed ? 33 : 65);
+	  BN.prototype._init = function init (number, base, endian) {
+	    if (typeof number === 'number') {
+	      return this._initNumber(number, base, endian);
+	    }
 
-      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 (typeof number === 'object') {
+	      return this._initArray(number, base, endian);
+	    }
 
-    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: {}};
-
-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);
+	    if (base === 'hex') {
+	      base = 16;
+	    }
+	    assert(base === (base | 0) && base >= 2 && base <= 36);
 
 	    number = number.toString().replace(/\s+/g, '');
 	    var start = 0;
@@ -16864,14 +16541,14 @@ bn.exports;
 
 var bnExports = bn.exports;
 
-var minimalisticAssert = assert$f;
+var minimalisticAssert = assert$g;
 
-function assert$f(val, msg) {
+function assert$g(val, msg) {
   if (!val)
     throw new Error(msg || 'Assertion failed');
 }
 
-assert$f.equal = function assertEqual(l, r, msg) {
+assert$g.equal = function assertEqual(l, r, msg) {
   if (l != r)
     throw new Error(msg || ('Assertion failed: ' + l + ' != ' + r));
 };
@@ -17134,7 +16811,7 @@ var BN$8 = bnExports;
 var utils$m = utils$o;
 var getNAF = utils$m.getNAF;
 var getJSF = utils$m.getJSF;
-var assert$e = utils$m.assert;
+var assert$f = utils$m.assert;
 
 function BaseCurve(type, conf) {
   this.type = type;
@@ -17180,7 +16857,7 @@ BaseCurve.prototype.validate = function validate() {
 };
 
 BaseCurve.prototype._fixedNafMul = function _fixedNafMul(p, k) {
-  assert$e(p.precomputed);
+  assert$f(p.precomputed);
   var doubles = p._getDoubles();
 
   var naf = getNAF(k, 1, this._bitLength);
@@ -17237,7 +16914,7 @@ BaseCurve.prototype._wnafMul = function _wnafMul(p, k) {
     if (i < 0)
       break;
     var z = naf[i];
-    assert$e(z !== 0);
+    assert$f(z !== 0);
     if (p.type === 'affine') {
       // J +- P
       if (z > 0)
@@ -17405,9 +17082,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$e(bytes[bytes.length - 1] % 2 === 0);
+      assert$f(bytes[bytes.length - 1] % 2 === 0);
     else if (bytes[0] === 0x07)
-      assert$e(bytes[bytes.length - 1] % 2 === 1);
+      assert$f(bytes[bytes.length - 1] % 2 === 1);
 
     var res =  this.point(bytes.slice(1, 1 + len),
       bytes.slice(1 + len, 1 + 2 * len));
@@ -17546,7 +17223,7 @@ var BN$7 = bnExports;
 var inherits$3 = inherits_browserExports;
 var Base$2 = base;
 
-var assert$d = utils$l.assert;
+var assert$e = utils$l.assert;
 
 function ShortCurve(conf) {
   Base$2.call(this, 'short', conf);
@@ -17591,7 +17268,7 @@ ShortCurve.prototype._getEndomorphism = function _getEndomorphism(conf) {
       lambda = lambdas[0];
     } else {
       lambda = lambdas[1];
-      assert$d(this.g.mul(lambda).x.cmp(this.g.x.redMul(beta)) === 0);
+      assert$e(this.g.mul(lambda).x.cmp(this.g.x.redMul(beta)) === 0);
     }
   }
 
@@ -18660,7 +18337,7 @@ var BN$5 = bnExports;
 var inherits$1 = inherits_browserExports;
 var Base = base;
 
-var assert$c = utils$j.assert;
+var assert$d = utils$j.assert;
 
 function EdwardsCurve(conf) {
   // NOTE: Important as we are creating point in Base.call()
@@ -18677,7 +18354,7 @@ function EdwardsCurve(conf) {
   this.d = new BN$5(conf.d, 16).toRed(this.red);
   this.dd = this.d.redAdd(this.d);
 
-  assert$c(!this.twisted || this.c.fromRed().cmpn(1) === 0);
+  assert$d(!this.twisted || this.c.fromRed().cmpn(1) === 0);
   this.oneC = (conf.c | 0) === 1;
 }
 inherits$1(EdwardsCurve, Base);
@@ -19105,7 +18782,7 @@ var hash$2 = {};
 
 var utils$i = {};
 
-var assert$b = minimalisticAssert;
+var assert$c = minimalisticAssert;
 var inherits = inherits_browserExports;
 
 utils$i.inherits = inherits;
@@ -19226,7 +18903,7 @@ utils$i.zero8 = zero8;
 
 function join32(msg, start, end, endian) {
   var len = end - start;
-  assert$b(len % 4 === 0);
+  assert$c(len % 4 === 0);
   var res = new Array(len / 4);
   for (var i = 0, k = start; i < res.length; i++, k += 4) {
     var w;
@@ -19385,7 +19062,7 @@ utils$i.shr64_lo = shr64_lo$1;
 var common$5 = {};
 
 var utils$h = utils$i;
-var assert$a = minimalisticAssert;
+var assert$b = minimalisticAssert;
 
 function BlockHash$4() {
   this.pending = null;
@@ -19430,7 +19107,7 @@ BlockHash$4.prototype.update = function update(msg, enc) {
 
 BlockHash$4.prototype.digest = function digest(enc) {
   this.update(this._pad());
-  assert$a(this.pending === null);
+  assert$b(this.pending === null);
 
   return this._digest(enc);
 };
@@ -19603,7 +19280,7 @@ SHA1.prototype._digest = function digest(enc) {
 var utils$e = utils$i;
 var common$2 = common$5;
 var shaCommon = common$4;
-var assert$9 = minimalisticAssert;
+var assert$a = minimalisticAssert;
 
 var sum32$1 = utils$e.sum32;
 var sum32_4$1 = utils$e.sum32_4;
@@ -19673,7 +19350,7 @@ SHA256$1.prototype._update = function _update(msg, start) {
   var g = this.h[6];
   var h = this.h[7];
 
-  assert$9(this.k.length === W.length);
+  assert$a(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));
@@ -19734,7 +19411,7 @@ SHA224.prototype._digest = function digest(enc) {
 
 var utils$c = utils$i;
 var common$1 = common$5;
-var assert$8 = minimalisticAssert;
+var assert$9 = minimalisticAssert;
 
 var rotr64_hi = utils$c.rotr64_hi;
 var rotr64_lo = utils$c.rotr64_lo;
@@ -19869,7 +19546,7 @@ SHA512$1.prototype._update = function _update(msg, start) {
   var hh = this.h[14];
   var hl = this.h[15];
 
-  assert$8(this.k.length === W.length);
+  assert$9(this.k.length === W.length);
   for (var i = 0; i < W.length; i += 2) {
     var c0_hi = hh;
     var c0_lo = hl;
@@ -20249,7 +19926,7 @@ var sh = [
 ];
 
 var utils$9 = utils$i;
-var assert$7 = minimalisticAssert;
+var assert$8 = minimalisticAssert;
 
 function Hmac(hash, key, enc) {
   if (!(this instanceof Hmac))
@@ -20268,7 +19945,7 @@ Hmac.prototype._init = function init(key) {
   // Shorten key, if needed
   if (key.length > this.blockSize)
     key = new this.Hash().update(key).digest();
-  assert$7(key.length <= this.blockSize);
+  assert$8(key.length <= this.blockSize);
 
   // Add padding to key
   for (var i = key.length; i < this.blockSize; i++)
@@ -21311,7 +20988,7 @@ function requireSecp256k1 () {
 
 var hash$1 = hash$2;
 var utils$8 = utils$n;
-var assert$6 = minimalisticAssert;
+var assert$7 = minimalisticAssert;
 
 function HmacDRBG$1(options) {
   if (!(this instanceof HmacDRBG$1))
@@ -21330,7 +21007,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$6(entropy.length >= (this.minEntropy / 8),
+  assert$7(entropy.length >= (this.minEntropy / 8),
          'Not enough entropy. Minimum is: ' + this.minEntropy + ' bits');
   this._init(entropy, nonce, pers);
 }
@@ -21385,7 +21062,7 @@ HmacDRBG$1.prototype.reseed = function reseed(entropy, entropyEnc, add, addEnc)
   entropy = utils$8.toArray(entropy, entropyEnc);
   add = utils$8.toArray(add, addEnc);
 
-  assert$6(entropy.length >= (this.minEntropy / 8),
+  assert$7(entropy.length >= (this.minEntropy / 8),
          'Not enough entropy. Minimum is: ' + this.minEntropy + ' bits');
 
   this._update(entropy.concat(add || []));
@@ -21423,7 +21100,7 @@ HmacDRBG$1.prototype.generate = function generate(len, enc, add, addEnc) {
 
 var BN$4 = bnExports;
 var utils$7 = utils$o;
-var assert$5 = utils$7.assert;
+var assert$6 = utils$7.assert;
 
 function KeyPair$3(ec, options) {
   this.ec = ec;
@@ -21508,10 +21185,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$5(key.x, 'Need x coordinate');
+      assert$6(key.x, 'Need x coordinate');
     } else if (this.ec.curve.type === 'short' ||
                this.ec.curve.type === 'edwards') {
-      assert$5(key.x && key.y, 'Need both x and y coordinate');
+      assert$6(key.x && key.y, 'Need both x and y coordinate');
     }
     this.pub = this.ec.curve.point(key.x, key.y);
     return;
@@ -21522,7 +21199,7 @@ KeyPair$3.prototype._importPublic = function _importPublic(key, enc) {
 // ECDH
 KeyPair$3.prototype.derive = function derive(pub) {
   if(!pub.validate()) {
-    assert$5(pub.validate(), 'public point not validated');
+    assert$6(pub.validate(), 'public point not validated');
   }
   return pub.mul(this.priv).getX();
 };
@@ -21544,7 +21221,7 @@ KeyPair$3.prototype.inspect = function inspect() {
 var BN$3 = bnExports;
 
 var utils$6 = utils$o;
-var assert$4 = utils$6.assert;
+var assert$5 = utils$6.assert;
 
 function Signature$3(options, enc) {
   if (options instanceof Signature$3)
@@ -21553,7 +21230,7 @@ function Signature$3(options, enc) {
   if (this._importDER(options, enc))
     return;
 
-  assert$4(options.r && options.s, 'Signature without r or s');
+  assert$5(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)
@@ -21711,7 +21388,7 @@ var HmacDRBG = hmacDrbg;
 var utils$5 = utils$o;
 var curves$1 = curves$2;
 var rand = brorandExports;
-var assert$3 = utils$5.assert;
+var assert$4 = utils$5.assert;
 
 var KeyPair$2 = key$1;
 var Signature$2 = signature$1;
@@ -21722,7 +21399,7 @@ function EC$1(options) {
 
   // Shortcut `elliptic.ec(curve-name)`
   if (typeof options === 'string') {
-    assert$3(Object.prototype.hasOwnProperty.call(curves$1, options),
+    assert$4(Object.prototype.hasOwnProperty.call(curves$1, options),
       'Unknown curve ' + options);
 
     options = curves$1[options];
@@ -21900,7 +21577,7 @@ EC$1.prototype.verify = function verify(msg, signature, key, enc) {
 };
 
 EC$1.prototype.recoverPubKey = function(msg, signature, j, enc) {
-  assert$3((3 & j) === j, 'The recovery param is more than two bits');
+  assert$4((3 & j) === j, 'The recovery param is more than two bits');
   signature = new Signature$2(signature, enc);
 
   var n = this.n;
@@ -21949,7 +21626,7 @@ EC$1.prototype.getKeyRecoveryParam = function(e, signature, Q, enc) {
 };
 
 var utils$4 = utils$o;
-var assert$2 = utils$4.assert;
+var assert$3 = utils$4.assert;
 var parseBytes$2 = utils$4.parseBytes;
 var cachedProperty$1 = utils$4.cachedProperty;
 
@@ -22023,7 +21700,7 @@ cachedProperty$1(KeyPair$1, 'messagePrefix', function messagePrefix() {
 });
 
 KeyPair$1.prototype.sign = function sign(message) {
-  assert$2(this._secret, 'KeyPair can only verify');
+  assert$3(this._secret, 'KeyPair can only verify');
   return this.eddsa.sign(message, this);
 };
 
@@ -22032,7 +21709,7 @@ KeyPair$1.prototype.verify = function verify(message, sig) {
 };
 
 KeyPair$1.prototype.getSecret = function getSecret(enc) {
-  assert$2(this._secret, 'KeyPair is public only');
+  assert$3(this._secret, 'KeyPair is public only');
   return utils$4.encode(this.secret(), enc);
 };
 
@@ -22044,7 +21721,7 @@ var key = KeyPair$1;
 
 var BN$1 = bnExports;
 var utils$3 = utils$o;
-var assert$1 = utils$3.assert;
+var assert$2 = utils$3.assert;
 var cachedProperty = utils$3.cachedProperty;
 var parseBytes$1 = utils$3.parseBytes;
 
@@ -22069,7 +21746,7 @@ function Signature$1(eddsa, sig) {
     };
   }
 
-  assert$1(sig.R && sig.S, 'Signature without R or S');
+  assert$2(sig.R && sig.S, 'Signature without R or S');
 
   if (eddsa.isPoint(sig.R))
     this._R = sig.R;
@@ -22109,13 +21786,13 @@ var signature = Signature$1;
 var hash = hash$2;
 var curves = curves$2;
 var utils$2 = utils$o;
-var assert = utils$2.assert;
+var assert$1 = utils$2.assert;
 var parseBytes = utils$2.parseBytes;
 var KeyPair = key;
 var Signature = signature;
 
 function EDDSA(curve) {
-  assert(curve === 'ed25519', 'only tested with ed25519 so far');
+  assert$1(curve === 'ed25519', 'only tested with ed25519 so far');
 
   if (!(this instanceof EDDSA))
     return new EDDSA(curve);
@@ -22545,99 +22222,436 @@ var elliptic$1 = {
       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')
+        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)
+      }
+    },
 
-        return new BN(nonce)
-      };
-    }
+    publicKeyConvert (pubkey, compressed = true, output) {
+      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.publicKeyConvert(output, pubkey)) {
+        case 0:
+          return output
+        case 1:
+          throw new Error(errors.PUBKEY_PARSE)
+        case 2:
+          throw new Error(errors.PUBKEY_SERIALIZE)
+      }
+    },
 
-    let sig;
-    try {
-      sig = ec.sign(message, seckey, { canonical: true, k: noncefn, pers: data });
-    } catch (err) {
-      return 1
-    }
+    publicKeyNegate (pubkey, compressed = true, output) {
+      isUint8Array('public key', pubkey, [33, 65]);
+      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.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 0
-  },
+    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);
 
-  ecdsaVerify (sig, msg32, pubkey) {
-    const sigObj = { r: sig.subarray(0, 32), s: sig.subarray(32, 64) };
+      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)
+      }
+    },
 
-    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
+    publicKeyTweakAdd (pubkey, tweak, compressed = true, output) {
+      isUint8Array('public key', pubkey, [33, 65]);
+      isUint8Array('tweak', tweak, 32);
+      isCompressed(compressed);
+      output = getAssertedOutput(output, compressed ? 33 : 65);
 
-    const pair = loadPublicKey(pubkey);
-    if (pair === null) return 2
+      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)
+      }
+    },
 
-    const point = pair.getPublic();
-    const isValid = ec.verify(msg32, sigObj, point);
-    return isValid ? 0 : 3
-  },
+    publicKeyTweakMul (pubkey, tweak, compressed = true, output) {
+      isUint8Array('public key', pubkey, [33, 65]);
+      isUint8Array('tweak', tweak, 32);
+      isCompressed(compressed);
+      output = getAssertedOutput(output, compressed ? 33 : 65);
 
-  ecdsaRecover (output, sig, recid, msg32) {
-    const sigObj = { r: sig.slice(0, 32), s: sig.slice(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
+    signatureNormalize (sig) {
+      isUint8Array('signature', sig, 64);
 
-    if (sigr.isZero() || sigs.isZero()) return 2
+      switch (secp256k1.signatureNormalize(sig)) {
+        case 0:
+          return sig
+        case 1:
+          throw new Error(errors.SIG_PARSE)
+      }
+    },
 
-    // Can throw `throw new Error('Unable to find sencond key candinate');`
-    let point;
-    try {
-      point = ec.recoverPubKey(msg32, sigObj, recid);
-    } catch (err) {
-      return 2
-    }
+    signatureExport (sig, output) {
+      isUint8Array('signature', sig, 64);
+      output = getAssertedOutput(output, 72);
 
-    savePublicKey(output, point);
+      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)
+      }
+    },
 
-    return 0
-  },
+    signatureImport (sig, output) {
+      isUint8Array('signature', sig);
+      output = getAssertedOutput(output, 64);
 
-  ecdh (output, pubkey, seckey, data, hashfn, xbuf, ybuf) {
-    const pair = loadPublicKey(pubkey);
-    if (pair === null) return 1
+      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)
+      }
+    },
 
-    const scalar = new BN(seckey);
-    if (scalar.cmp(ecparams.n) >= 0 || scalar.isZero()) 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);
 
-    const point = pair.getPublic().mul(scalar);
+      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)
+      }
+    },
 
-    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];
+    ecdsaVerify (sig, msg32, pubkey) {
+      isUint8Array('signature', sig, 64);
+      isUint8Array('message', msg32, 32);
+      isUint8Array('public key', pubkey, [33, 65]);
 
-      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.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 hash = hashfn(xbuf, ybuf, data);
+    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 isValid = hash instanceof Uint8Array && hash.length === output.length;
-      if (!isValid) return 2
+      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)
+      }
+    },
 
-      output.set(hash);
-    }
+    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);
+      }
 
-    return 0
+      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)
+      }
+    }
   }
 };
 
@@ -24118,7 +24132,7 @@ b||"returnDetailedScanResult"in b)?(m=b.scanRegion,c=b.qrEngine,d=b.canvas,f=b.d
 [d,k]=e._drawToCanvas(p,m,d,f);let q;if(c instanceof Worker){let g=c;b||e._postWorkerMessageSync(g,"inversionMode","both");q=await new Promise((l,v)=>{let w,u,r,y=-1;u=t=>{t.data.id===y&&(g.removeEventListener("message",u),g.removeEventListener("error",r),clearTimeout(w),null!==t.data.data?l({data:t.data.data,cornerPoints:e._convertPoints(t.data.cornerPoints,m)}):v(e.NO_QR_CODE_FOUND));};r=t=>{g.removeEventListener("message",u);g.removeEventListener("error",r);clearTimeout(w);v("Scanner error: "+(t?
 t.message||t:"Unknown Error"));};g.addEventListener("message",u);g.addEventListener("error",r);w=setTimeout(()=>r("timeout"),1E4);let x=k.getImageData(0,0,d.width,d.height);y=e._postWorkerMessageSync(g,"decode",x,[x.data.buffer]);});}else q=await Promise.race([new Promise((g,l)=>window.setTimeout(()=>l("Scanner error: timeout"),1E4)),(async()=>{try{var [g]=await c.detect(d);if(!g)throw e.NO_QR_CODE_FOUND;return {data:g.rawValue,cornerPoints:e._convertPoints(g.cornerPoints,m)}}catch(l){g=l.message||l;
 if(/not implemented|service unavailable/.test(g))return e._disableBarcodeDetector=!0,e.scanImage(a,{scanRegion:m,canvas:d,disallowCanvasResizing:f,alsoTryWithoutScanRegion:h});throw `Scanner error: ${g}`;}})()]);return n?q:q.data}catch(p){if(!m||!h)throw p;let k=await e.scanImage(a,{qrEngine:c,canvas:d,disallowCanvasResizing:f});return n?k:k.data}finally{b||e._postWorkerMessage(c,"close");}}setGrayscaleWeights(a,b,c,d=!0){e._postWorkerMessage(this._qrEnginePromise,"grayscaleWeights",{red:a,green:b,
-blue:c,useIntegerApproximation:d});}setInversionMode(a){e._postWorkerMessage(this._qrEnginePromise,"inversionMode",a);}static async createQrEngine(a){a&&console.warn("Specifying a worker path is not required and not supported anymore.");a=()=>import('./qr-scanner-worker.min-c002e984.js').then(c=>c.createWorker());if(!(!e._disableBarcodeDetector&&"BarcodeDetector"in window&&BarcodeDetector.getSupportedFormats&&(await BarcodeDetector.getSupportedFormats()).includes("qr_code")))return a();let b=navigator.userAgentData;
+blue:c,useIntegerApproximation:d});}setInversionMode(a){e._postWorkerMessage(this._qrEnginePromise,"inversionMode",a);}static async createQrEngine(a){a&&console.warn("Specifying a worker path is not required and not supported anymore.");a=()=>import('./qr-scanner-worker.min-RaSiJc_R.js').then(c=>c.createWorker());if(!(!e._disableBarcodeDetector&&"BarcodeDetector"in window&&BarcodeDetector.getSupportedFormats&&(await BarcodeDetector.getSupportedFormats()).includes("qr_code")))return a();let b=navigator.userAgentData;
 return b&&b.brands.some(({brand:c})=>/Chromium/i.test(c))&&/mac ?OS/i.test(b.platform)&&await b.getHighEntropyValues(["architecture","platformVersion"]).then(({architecture:c,platformVersion:d})=>/arm/i.test(c||"arm")&&13<=parseInt(d||"13")).catch(()=>!0)?a():new BarcodeDetector({formats:["qr_code"]})}_onPlay(){this._scanRegion=this._calculateScanRegion(this.$video);this._updateOverlay();this.$overlay&&(this.$overlay.style.display="");this._scanFrame();}_onLoadedMetaData(){this._scanRegion=this._calculateScanRegion(this.$video);
 this._updateOverlay();}_onVisibilityChange(){document.hidden?this.pause():this._active&&this.start();}_calculateScanRegion(a){let b=Math.round(2/3*Math.min(a.videoWidth,a.videoHeight));return {x:Math.round((a.videoWidth-b)/2),y:Math.round((a.videoHeight-b)/2),width:b,height:b,downScaledWidth:this._legacyCanvasSize,downScaledHeight:this._legacyCanvasSize}}_updateOverlay(){requestAnimationFrame(()=>{if(this.$overlay){var a=this.$video,b=a.videoWidth,c=a.videoHeight,d=a.offsetWidth,f=a.offsetHeight,h=a.offsetLeft,
 m=a.offsetTop,n=window.getComputedStyle(a),p=n.objectFit,k=b/c,q=d/f;switch(p){case "none":var g=b;var l=c;break;case "fill":g=d;l=f;break;default:("cover"===p?k>q:k<q)?(l=f,g=l*k):(g=d,l=g/k),"scale-down"===p&&(g=Math.min(g,b),l=Math.min(l,c));}var [v,w]=n.objectPosition.split(" ").map((r,y)=>{const x=parseFloat(r);return r.endsWith("%")?(y?f-l:d-g)*x/100:x});n=this._scanRegion.width||b;q=this._scanRegion.height||c;p=this._scanRegion.x||0;var u=this._scanRegion.y||0;k=this.$overlay.style;k.width=
@@ -27092,7 +27106,7 @@ class Identity {
             this.selectedAccount = new TextDecoder().decode(selected);
         }
         else {
-            const importee = await import(/* webpackChunkName: "generate-account" */ './index-81687e93.js');
+            const importee = await import(/* webpackChunkName: "generate-account" */ './index-Wv-fIkmw.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));
@@ -27283,7 +27297,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-cccb78db.js');
+         } = await import(/* webpackChunkName: "messages" */ './messages-y2oPb2AE.js');
         /**
          * proto Object containing protos
          * @type {Object}
@@ -27377,7 +27391,7 @@ class Peernet {
         if (this.#starting || this.#started)
             return;
         this.#starting = true;
-        const importee = await import('./client-f193279c.js');
+        const importee = await import('./client-peGn0FvK.js');
         /**
          * @access public
          * @type {PeernetClient}