@airgap/coinlib-core 0.13.11-beta.1 → 0.13.11-beta.2

package/dependencies/src/debug-3.1.0/src/browser.js

@@ -0,0 +1,195 @@
+/**
+ * This is the web browser implementation of `debug()`.
+ *
+ * Expose `debug()` as the module.
+ */
+
+exports = module.exports = require('./debug');
+exports.log = log;
+exports.formatArgs = formatArgs;
+exports.save = save;
+exports.load = load;
+exports.useColors = useColors;
+exports.storage = 'undefined' != typeof chrome
+               && 'undefined' != typeof chrome.storage
+                  ? chrome.storage.local
+                  : localstorage();
+
+/**
+ * Colors.
+ */
+
+exports.colors = [
+  '#0000CC', '#0000FF', '#0033CC', '#0033FF', '#0066CC', '#0066FF', '#0099CC',
+  '#0099FF', '#00CC00', '#00CC33', '#00CC66', '#00CC99', '#00CCCC', '#00CCFF',
+  '#3300CC', '#3300FF', '#3333CC', '#3333FF', '#3366CC', '#3366FF', '#3399CC',
+  '#3399FF', '#33CC00', '#33CC33', '#33CC66', '#33CC99', '#33CCCC', '#33CCFF',
+  '#6600CC', '#6600FF', '#6633CC', '#6633FF', '#66CC00', '#66CC33', '#9900CC',
+  '#9900FF', '#9933CC', '#9933FF', '#99CC00', '#99CC33', '#CC0000', '#CC0033',
+  '#CC0066', '#CC0099', '#CC00CC', '#CC00FF', '#CC3300', '#CC3333', '#CC3366',
+  '#CC3399', '#CC33CC', '#CC33FF', '#CC6600', '#CC6633', '#CC9900', '#CC9933',
+  '#CCCC00', '#CCCC33', '#FF0000', '#FF0033', '#FF0066', '#FF0099', '#FF00CC',
+  '#FF00FF', '#FF3300', '#FF3333', '#FF3366', '#FF3399', '#FF33CC', '#FF33FF',
+  '#FF6600', '#FF6633', '#FF9900', '#FF9933', '#FFCC00', '#FFCC33'
+];
+
+/**
+ * Currently only WebKit-based Web Inspectors, Firefox >= v31,
+ * and the Firebug extension (any Firefox version) are known
+ * to support "%c" CSS customizations.
+ *
+ * TODO: add a `localStorage` variable to explicitly enable/disable colors
+ */
+
+function useColors() {
+  // NB: In an Electron preload script, document will be defined but not fully
+  // initialized. Since we know we're in Chrome, we'll just detect this case
+  // explicitly
+  if (typeof window !== 'undefined' && window.process && window.process.type === 'renderer') {
+    return true;
+  }
+
+  // Internet Explorer and Edge do not support colors.
+  if (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
+    return false;
+  }
+
+  // is webkit? http://stackoverflow.com/a/16459606/376773
+  // document is undefined in react-native: https://github.com/facebook/react-native/pull/1632
+  return (typeof document !== 'undefined' && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance) ||
+    // is firebug? http://stackoverflow.com/a/398120/376773
+    (typeof window !== 'undefined' && window.console && (window.console.firebug || (window.console.exception && window.console.table))) ||
+    // is firefox >= v31?
+    // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
+    (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31) ||
+    // double check webkit in userAgent just in case we are in a worker
+    (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/));
+}
+
+/**
+ * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.
+ */
+
+exports.formatters.j = function(v) {
+  try {
+    return JSON.stringify(v);
+  } catch (err) {
+    return '[UnexpectedJSONParseError]: ' + err.message;
+  }
+};
+
+
+/**
+ * Colorize log arguments if enabled.
+ *
+ * @api public
+ */
+
+function formatArgs(args) {
+  var useColors = this.useColors;
+
+  args[0] = (useColors ? '%c' : '')
+    + this.namespace
+    + (useColors ? ' %c' : ' ')
+    + args[0]
+    + (useColors ? '%c ' : ' ')
+    + '+' + exports.humanize(this.diff);
+
+  if (!useColors) return;
+
+  var c = 'color: ' + this.color;
+  args.splice(1, 0, c, 'color: inherit')
+
+  // the final "%c" is somewhat tricky, because there could be other
+  // arguments passed either before or after the %c, so we need to
+  // figure out the correct index to insert the CSS into
+  var index = 0;
+  var lastC = 0;
+  args[0].replace(/%[a-zA-Z%]/g, function(match) {
+    if ('%%' === match) return;
+    index++;
+    if ('%c' === match) {
+      // we only are interested in the *last* %c
+      // (the user may have provided their own)
+      lastC = index;
+    }
+  });
+
+  args.splice(lastC, 0, c);
+}
+
+/**
+ * Invokes `console.log()` when available.
+ * No-op when `console.log` is not a "function".
+ *
+ * @api public
+ */
+
+function log() {
+  // this hackery is required for IE8/9, where
+  // the `console.log` function doesn't have 'apply'
+  return 'object' === typeof console
+    && console.log
+    && Function.prototype.apply.call(console.log, console, arguments);
+}
+
+/**
+ * Save `namespaces`.
+ *
+ * @param {String} namespaces
+ * @api private
+ */
+
+function save(namespaces) {
+  try {
+    if (null == namespaces) {
+      exports.storage.removeItem('debug');
+    } else {
+      exports.storage.debug = namespaces;
+    }
+  } catch(e) {}
+}
+
+/**
+ * Load `namespaces`.
+ *
+ * @return {String} returns the previously persisted debug modes
+ * @api private
+ */
+
+function load() {
+  var r;
+  try {
+    r = exports.storage.debug;
+  } catch(e) {}
+
+  // If debug isn't set in LS, and we're in Electron, try to load $DEBUG
+  if (!r && typeof process !== 'undefined' && 'env' in process) {
+    r = process.env.DEBUG;
+  }
+
+  return r;
+}
+
+/**
+ * Enable namespaces listed in `localStorage.debug` initially.
+ */
+
+exports.enable(load());
+
+/**
+ * Localstorage attempts to return the localstorage.
+ *
+ * This is necessary because safari throws
+ * when a user disables cookies/localstorage
+ * and you attempt to access it.
+ *
+ * @return {LocalStorage}
+ * @api private
+ */
+
+function localstorage() {
+  try {
+    return window.localStorage;
+  } catch (e) {}
+}

package/dependencies/src/debug-3.1.0/src/debug.js

@@ -0,0 +1,225 @@
+
+/**
+ * This is the common logic for both the Node.js and web browser
+ * implementations of `debug()`.
+ *
+ * Expose `debug()` as the module.
+ */
+
+exports = module.exports = createDebug.debug = createDebug['default'] = createDebug;
+exports.coerce = coerce;
+exports.disable = disable;
+exports.enable = enable;
+exports.enabled = enabled;
+exports.humanize = require('../../ms-2.1.2/index');
+
+/**
+ * Active `debug` instances.
+ */
+exports.instances = [];
+
+/**
+ * The currently active debug mode names, and names to skip.
+ */
+
+exports.names = [];
+exports.skips = [];
+
+/**
+ * Map of special "%n" handling functions, for the debug "format" argument.
+ *
+ * Valid key names are a single, lower or upper-case letter, i.e. "n" and "N".
+ */
+
+exports.formatters = {};
+
+/**
+ * Select a color.
+ * @param {String} namespace
+ * @return {Number}
+ * @api private
+ */
+
+function selectColor(namespace) {
+  var hash = 0, i;
+
+  for (i in namespace) {
+    hash  = ((hash << 5) - hash) + namespace.charCodeAt(i);
+    hash |= 0; // Convert to 32bit integer
+  }
+
+  return exports.colors[Math.abs(hash) % exports.colors.length];
+}
+
+/**
+ * Create a debugger with the given `namespace`.
+ *
+ * @param {String} namespace
+ * @return {Function}
+ * @api public
+ */
+
+function createDebug(namespace) {
+
+  var prevTime;
+
+  function debug() {
+    // disabled?
+    if (!debug.enabled) return;
+
+    var self = debug;
+
+    // set `diff` timestamp
+    var curr = +new Date();
+    var ms = curr - (prevTime || curr);
+    self.diff = ms;
+    self.prev = prevTime;
+    self.curr = curr;
+    prevTime = curr;
+
+    // turn the `arguments` into a proper Array
+    var args = new Array(arguments.length);
+    for (var i = 0; i < args.length; i++) {
+      args[i] = arguments[i];
+    }
+
+    args[0] = exports.coerce(args[0]);
+
+    if ('string' !== typeof args[0]) {
+      // anything else let's inspect with %O
+      args.unshift('%O');
+    }
+
+    // apply any `formatters` transformations
+    var index = 0;
+    args[0] = args[0].replace(/%([a-zA-Z%])/g, function(match, format) {
+      // if we encounter an escaped % then don't increase the array index
+      if (match === '%%') return match;
+      index++;
+      var formatter = exports.formatters[format];
+      if ('function' === typeof formatter) {
+        var val = args[index];
+        match = formatter.call(self, val);
+
+        // now we need to remove `args[index]` since it's inlined in the `format`
+        args.splice(index, 1);
+        index--;
+      }
+      return match;
+    });
+
+    // apply env-specific formatting (colors, etc.)
+    exports.formatArgs.call(self, args);
+
+    var logFn = debug.log || exports.log || console.log.bind(console);
+    logFn.apply(self, args);
+  }
+
+  debug.namespace = namespace;
+  debug.enabled = exports.enabled(namespace);
+  debug.useColors = exports.useColors();
+  debug.color = selectColor(namespace);
+  debug.destroy = destroy;
+
+  // env-specific initialization logic for debug instances
+  if ('function' === typeof exports.init) {
+    exports.init(debug);
+  }
+
+  exports.instances.push(debug);
+
+  return debug;
+}
+
+function destroy () {
+  var index = exports.instances.indexOf(this);
+  if (index !== -1) {
+    exports.instances.splice(index, 1);
+    return true;
+  } else {
+    return false;
+  }
+}
+
+/**
+ * Enables a debug mode by namespaces. This can include modes
+ * separated by a colon and wildcards.
+ *
+ * @param {String} namespaces
+ * @api public
+ */
+
+function enable(namespaces) {
+  exports.save(namespaces);
+
+  exports.names = [];
+  exports.skips = [];
+
+  var i;
+  var split = (typeof namespaces === 'string' ? namespaces : '').split(/[\s,]+/);
+  var len = split.length;
+
+  for (i = 0; i < len; i++) {
+    if (!split[i]) continue; // ignore empty strings
+    namespaces = split[i].replace(/\*/g, '.*?');
+    if (namespaces[0] === '-') {
+      exports.skips.push(new RegExp('^' + namespaces.substr(1) + '$'));
+    } else {
+      exports.names.push(new RegExp('^' + namespaces + '$'));
+    }
+  }
+
+  for (i = 0; i < exports.instances.length; i++) {
+    var instance = exports.instances[i];
+    instance.enabled = exports.enabled(instance.namespace);
+  }
+}
+
+/**
+ * Disable debug output.
+ *
+ * @api public
+ */
+
+function disable() {
+  exports.enable('');
+}
+
+/**
+ * Returns true if the given mode name is enabled, false otherwise.
+ *
+ * @param {String} name
+ * @return {Boolean}
+ * @api public
+ */
+
+function enabled(name) {
+  if (name[name.length - 1] === '*') {
+    return true;
+  }
+  var i, len;
+  for (i = 0, len = exports.skips.length; i < len; i++) {
+    if (exports.skips[i].test(name)) {
+      return false;
+    }
+  }
+  for (i = 0, len = exports.names.length; i < len; i++) {
+    if (exports.names[i].test(name)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Coerce `val`.
+ *
+ * @param {Mixed} val
+ * @return {Mixed}
+ * @api private
+ */
+
+function coerce(val) {
+  if (val instanceof Error) return val.stack || val.message;
+  return val;
+}

package/dependencies/src/drbg.js-1.0.1/hash.js

@@ -0,0 +1,92 @@
+'use strict'
+var createHash = require('../create-hash-1.2.0/browser')
+var hashInfo = require('./lib/hash-info.json')
+var util = require('./lib/util')
+
+var ebuf = new Buffer(0)
+var b0x00 = new Buffer([ 0x00 ])
+var b0x01 = new Buffer([ 0x01 ])
+var b0x02 = new Buffer([ 0x02 ])
+var b0x03 = new Buffer([ 0x03 ])
+
+function HashDRBG (algo, entropy, nonce, pers) {
+  var info = hashInfo[algo]
+  if (info === undefined) throw new Error('hash ' + algo + ' is not supported')
+
+  this._algo = algo
+  this._securityStrength = info.securityStrength / 8
+  this._outlen = info.outlen / 8
+  this._seedlen = info.seedlen / 8
+  this._reseedInterval = 0x1000000000000 // 2**48
+
+  this._init(entropy, nonce, pers)
+}
+
+HashDRBG.prototype._hashdf = function (input, len) {
+  var data = Buffer.concat([
+    new Buffer([ 0x01 ]),
+    new Buffer([ (len >>> 21) & 0xff, (len >>> 13) & 0xff, (len >>> 5) & 0xff, (len & 0x1f) << 3 ]),
+    input
+  ])
+
+  var temp = new Buffer(0)
+  for (var i = 1, m = Math.ceil(len / this._outlen); i <= m; ++i) {
+    temp = Buffer.concat([ temp, createHash(this._algo).update(data).digest() ])
+    data[0] += 1
+  }
+
+  return temp.slice(0, len)
+}
+
+HashDRBG.prototype._init = function (entropy, nonce, pers) {
+  if (entropy.length < this._securityStrength) throw new Error('Not enough entropy')
+
+  var seedMaterial = Buffer.concat([ entropy, nonce, pers || ebuf ])
+  this._V = this._hashdf(seedMaterial, this._seedlen)
+  this._C = this._hashdf(Buffer.concat([ b0x00, this._V ]), this._seedlen)
+  this._reseed = 1
+}
+
+HashDRBG.prototype.reseed = function (entropy, add) {
+  if (entropy.length < this._securityStrength) throw new Error('Not enough entropy')
+
+  var seedMaterial = Buffer.concat([ b0x01, this._V, entropy, add || ebuf ])
+  this._V = this._hashdf(seedMaterial, this._seedlen)
+  this._C = this._hashdf(Buffer.concat([ b0x00, this._V ]), this._seedlen)
+  this._reseed = 1
+}
+
+HashDRBG.prototype.generate = function (len, add) {
+  if (this._reseed > this._reseedInterval) throw new Error('Reseed is required')
+
+  if (add && add.length !== 0) {
+    var data = Buffer.concat([ b0x02, this._V, add ])
+    var w = createHash(this._algo).update(data).digest()
+    this._V = util.bsum([ this._V, w ])
+  }
+
+  var result = this._hashgen(len)
+
+  var H = createHash(this._algo).update(Buffer.concat([ b0x03, this._V ])).digest()
+  var bReseed = new Buffer(8)
+  bReseed.writeUInt32BE((this._reseed / 0x0100000000) | 0, 0)
+  bReseed.writeUInt32BE(this._reseed >>> 0, 4)
+  this._V = util.bsum([ this._V, H, this._C, bReseed ])
+
+  this._reseed += 1
+  return result
+}
+
+HashDRBG.prototype._hashgen = function (len) {
+  var data = new Buffer(this._V)
+  var W = new Buffer(0)
+  while (W.length < len) {
+    var w = createHash(this._algo).update(data).digest()
+    W = Buffer.concat([ W, w ])
+    data = util.bsum([ data, b0x01 ])
+  }
+
+  return W.slice(0, len)
+}
+
+module.exports = HashDRBG

package/dependencies/src/drbg.js-1.0.1/hmac.js

@@ -0,0 +1,71 @@
+'use strict'
+var createHmac = require('../create-hmac-1.1.4/browser')
+var hashInfo = require('./lib/hash-info.json')
+
+var ebuf = new Buffer(0)
+var b0x00 = new Buffer([ 0x00 ])
+var b0x01 = new Buffer([ 0x01 ])
+
+function HmacDRBG (algo, entropy, nonce, pers) {
+  var info = hashInfo[algo]
+  if (info === undefined) throw new Error('hash ' + algo + ' is not supported')
+
+  this._algo = algo
+  this._securityStrength = info.securityStrength / 8
+  this._outlen = info.outlen / 8
+  this._reseedInterval = 0x1000000000000 // 2**48
+
+  this._init(entropy, nonce, pers)
+}
+
+HmacDRBG.prototype._update = function (seed) {
+  var kmac = createHmac(this._algo, this._K).update(this._V).update(b0x00)
+  if (seed) kmac.update(seed)
+
+  this._K = kmac.digest()
+  this._V = createHmac(this._algo, this._K).update(this._V).digest()
+  if (!seed) return
+
+  this._K = createHmac(this._algo, this._K).update(this._V).update(b0x01).update(seed).digest()
+  this._V = createHmac(this._algo, this._K).update(this._V).digest()
+}
+
+HmacDRBG.prototype._init = function (entropy, nonce, pers) {
+  if (entropy.length < this._securityStrength) throw new Error('Not enough entropy')
+
+  this._K = new Buffer(this._outlen)
+  this._V = new Buffer(this._outlen)
+  for (var i = 0; i < this._K.length; ++i) {
+    this._K[i] = 0x00
+    this._V[i] = 0x01
+  }
+
+  this._update(Buffer.concat([ entropy, nonce, pers || ebuf ]))
+  this._reseed = 1
+}
+
+HmacDRBG.prototype.reseed = function (entropy, add) {
+  if (entropy.length < this._securityStrength) throw new Error('Not enough entropy')
+
+  this._update(Buffer.concat([ entropy, add || ebuf ]))
+  this._reseed = 1
+}
+
+HmacDRBG.prototype.generate = function (len, add) {
+  if (this._reseed > this._reseedInterval) throw new Error('Reseed is required')
+
+  if (add && add.length === 0) add = undefined
+  if (add) this._update(add)
+
+  var temp = new Buffer(0)
+  while (temp.length < len) {
+    this._V = createHmac(this._algo, this._K).update(this._V).digest()
+    temp = Buffer.concat([ temp, this._V ])
+  }
+
+  this._update(add)
+  this._reseed += 1
+  return temp.slice(0, len)
+}
+
+module.exports = HmacDRBG

package/dependencies/src/drbg.js-1.0.1/index.js

@@ -0,0 +1,4 @@
+'use strict'
+// module.exports.CtrDRBG = require('./ctr')
+module.exports.HashDRBG = require('./hash')
+module.exports.HmacDRBG = require('./hmac')

package/dependencies/src/drbg.js-1.0.1/lib/hash-info.json

@@ -0,0 +1,27 @@
+{
+    "sha1": {
+        "securityStrength": 128,
+        "outlen": 160,
+        "seedlen": 440
+    },
+    "sha224": {
+        "securityStrength": 192,
+        "outlen": 224,
+        "seedlen": 440
+    },
+    "sha256": {
+        "securityStrength": 256,
+        "outlen": 256,
+        "seedlen": 440
+    },
+    "sha384": {
+        "securityStrength": 256,
+        "outlen": 384,
+        "seedlen": 888
+    },
+    "sha512": {
+        "securityStrength": 256,
+        "outlen": 512,
+        "seedlen": 888
+    }
+}

package/dependencies/src/drbg.js-1.0.1/lib/util.js

@@ -0,0 +1,36 @@
+'use strict'
+exports.b512zero = new Buffer(256)
+;(function () {
+  for (var i = 0; i < exports.b512zero.length; ++i) exports.b512zero[i] = 0
+})()
+
+exports.bKsource = new Buffer(32)
+;(function () {
+  for (var i = 0; i < exports.bKsource.length; ++i) exports.bKsource[i] = i
+})()
+
+exports.bsum = function (buffers) {
+  var dst = new Buffer(buffers[0])
+
+  for (var i = 1; i < buffers.length; ++i) {
+    for (var j = buffers[i].length - 1, dj = dst.length - 1, carry = 0; j >= 0; --j, --dj) {
+      carry += buffers[i][j] + dst[dj]
+      dst[dj] = carry & 0xff
+      carry >>>= 8
+    }
+
+    for (; carry > 0 && dj >= 0; --dj) {
+      carry += dst[dj]
+      dst[dj] = carry & 0xff
+      carry >>>= 8
+    }
+  }
+
+  return dst
+}
+
+exports.bxor = function (a, b) {
+  var r = new Buffer(a.length)
+  for (var i = 0; i < r.length; ++i) r[i] = a[i] ^ b[i]
+  return r
+}

package/dependencies/src/eciesjs-0.3.9/src/index.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="node" />
+import { aesDecrypt, aesEncrypt, decodeHex, getValidSecret, remove0x } from "./utils";
+export declare function encrypt(receiverRawPub: string | Buffer, msg: Buffer): Buffer;
+export declare function decrypt(receiverRawPrv: string | Buffer, msg: Buffer): Buffer;
+export { PrivateKey, PublicKey } from "./keys";
+export declare const utils: {
+    aesDecrypt: typeof aesDecrypt;
+    aesEncrypt: typeof aesEncrypt;
+    decodeHex: typeof decodeHex;
+    getValidSecret: typeof getValidSecret;
+    remove0x: typeof remove0x;
+};

package/dependencies/src/eciesjs-0.3.9/src/index.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.utils = exports.PublicKey = exports.PrivateKey = exports.decrypt = exports.encrypt = void 0;
+var keys_1 = require("./keys");
+var utils_1 = require("./utils");
+var UNCOMPRESSED_PUBLIC_KEY_SIZE = 65;
+function encrypt(receiverRawPub, msg) {
+    var ephemeralKey = new keys_1.PrivateKey();
+    var receiverPubkey = receiverRawPub instanceof Buffer ?
+        new keys_1.PublicKey(receiverRawPub) : keys_1.PublicKey.fromHex(receiverRawPub);
+    var aesKey = ephemeralKey.encapsulate(receiverPubkey);
+    var encrypted = (0, utils_1.aesEncrypt)(aesKey, msg);
+    return Buffer.concat([ephemeralKey.publicKey.uncompressed, encrypted]);
+}
+exports.encrypt = encrypt;
+function decrypt(receiverRawPrv, msg) {
+    var receiverPrvkey = receiverRawPrv instanceof Buffer ?
+        new keys_1.PrivateKey(receiverRawPrv) : keys_1.PrivateKey.fromHex(receiverRawPrv);
+    var senderPubkey = new keys_1.PublicKey(msg.slice(0, UNCOMPRESSED_PUBLIC_KEY_SIZE));
+    var encrypted = msg.slice(UNCOMPRESSED_PUBLIC_KEY_SIZE);
+    var aesKey = senderPubkey.decapsulate(receiverPrvkey);
+    return (0, utils_1.aesDecrypt)(aesKey, encrypted);
+}
+exports.decrypt = decrypt;
+var keys_2 = require("./keys");
+Object.defineProperty(exports, "PrivateKey", { enumerable: true, get: function () { return keys_2.PrivateKey; } });
+Object.defineProperty(exports, "PublicKey", { enumerable: true, get: function () { return keys_2.PublicKey; } });
+exports.utils = {
+    aesDecrypt: utils_1.aesDecrypt,
+    aesEncrypt: utils_1.aesEncrypt,
+    decodeHex: utils_1.decodeHex,
+    getValidSecret: utils_1.getValidSecret,
+    remove0x: utils_1.remove0x,
+};
+//# sourceMappingURL=index.js.map