@xchainjs/xchain-thorchain 1.1.0 → 1.1.1

package/lib/index.js

@@ -5540,13 +5540,13 @@ function requireMinimal () {
 
 var writer = Writer$1;
 
-var util$7      = requireMinimal();
+var util$5      = requireMinimal();
 
 var BufferWriter$1; // cyclic
 
-var LongBits$1  = util$7.LongBits,
-    base64    = util$7.base64,
-    utf8$1      = util$7.utf8;
+var LongBits$1  = util$5.LongBits,
+    base64    = util$5.base64,
+    utf8$1      = util$5.utf8;
 
 /**
  * Constructs a new writer operation instance.
@@ -5661,7 +5661,7 @@ function Writer$1() {
 }
 
 var create$1 = function create() {
-    return util$7.Buffer
+    return util$5.Buffer
         ? function create_buffer_setup() {
             return (Writer$1.create = function create_buffer() {
                 return new BufferWriter$1();
@@ -5686,13 +5686,13 @@ Writer$1.create = create$1();
  * @returns {Uint8Array} Buffer
  */
 Writer$1.alloc = function alloc(size) {
-    return new util$7.Array(size);
+    return new util$5.Array(size);
 };
 
 // Use Uint8Array buffer pool in the browser, just like node does with buffers
 /* istanbul ignore else */
-if (util$7.Array !== Array)
-    Writer$1.alloc = util$7.pool(Writer$1.alloc, util$7.Array.prototype.subarray);
+if (util$5.Array !== Array)
+    Writer$1.alloc = util$5.pool(Writer$1.alloc, util$5.Array.prototype.subarray);
 
 /**
  * Pushes a new operation to the queue.
@@ -5882,7 +5882,7 @@ Writer$1.prototype.sfixed64 = Writer$1.prototype.fixed64;
  * @returns {Writer} `this`
  */
 Writer$1.prototype.float = function write_float(value) {
-    return this._push(util$7.float.writeFloatLE, 4, value);
+    return this._push(util$5.float.writeFloatLE, 4, value);
 };
 
 /**
@@ -5892,10 +5892,10 @@ Writer$1.prototype.float = function write_float(value) {
  * @returns {Writer} `this`
  */
 Writer$1.prototype.double = function write_double(value) {
-    return this._push(util$7.float.writeDoubleLE, 8, value);
+    return this._push(util$5.float.writeDoubleLE, 8, value);
 };
 
-var writeBytes = util$7.Array.prototype.set
+var writeBytes = util$5.Array.prototype.set
     ? function writeBytes_set(val, buf, pos) {
         buf.set(val, pos); // also works for plain array values
     }
@@ -5914,7 +5914,7 @@ Writer$1.prototype.bytes = function write_bytes(value) {
     var len = value.length >>> 0;
     if (!len)
         return this._push(writeByte, 1, 0);
-    if (util$7.isString(value)) {
+    if (util$5.isString(value)) {
         var buf = Writer$1.alloc(len = base64.length(value));
         base64.decode(value, buf, 0);
         value = buf;
@@ -6009,7 +6009,7 @@ var writer_buffer = BufferWriter;
 var Writer = writer;
 (BufferWriter.prototype = Object.create(Writer.prototype)).constructor = BufferWriter;
 
-var util$6 = requireMinimal();
+var util$4 = requireMinimal();
 
 /**
  * Constructs a new buffer writer instance.
@@ -6028,9 +6028,9 @@ BufferWriter._configure = function () {
      * @param {number} size Buffer size
      * @returns {Buffer} Buffer
      */
-    BufferWriter.alloc = util$6._Buffer_allocUnsafe;
+    BufferWriter.alloc = util$4._Buffer_allocUnsafe;
 
-    BufferWriter.writeBytesBuffer = util$6.Buffer && util$6.Buffer.prototype instanceof Uint8Array && util$6.Buffer.prototype.set.name === "set"
+    BufferWriter.writeBytesBuffer = util$4.Buffer && util$4.Buffer.prototype instanceof Uint8Array && util$4.Buffer.prototype.set.name === "set"
         ? function writeBytesBuffer_set(val, buf, pos) {
           buf.set(val, pos); // faster than copy (requires node >= 4 where Buffers extend Uint8Array and set is properly inherited)
           // also works for plain array values
@@ -6049,8 +6049,8 @@ BufferWriter._configure = function () {
  * @override
  */
 BufferWriter.prototype.bytes = function write_bytes_buffer(value) {
-    if (util$6.isString(value))
-        value = util$6._Buffer_from(value, "base64");
+    if (util$4.isString(value))
+        value = util$4._Buffer_from(value, "base64");
     var len = value.length >>> 0;
     this.uint32(len);
     if (len)
@@ -6060,7 +6060,7 @@ BufferWriter.prototype.bytes = function write_bytes_buffer(value) {
 
 function writeStringBuffer(val, buf, pos) {
     if (val.length < 40) // plain js is faster for short strings (probably due to redundant assertions)
-        util$6.utf8.write(val, buf, pos);
+        util$4.utf8.write(val, buf, pos);
     else if (buf.utf8Write)
         buf.utf8Write(val, pos);
     else
@@ -6071,7 +6071,7 @@ function writeStringBuffer(val, buf, pos) {
  * @override
  */
 BufferWriter.prototype.string = function write_string_buffer(value) {
-    var len = util$6.Buffer.byteLength(value);
+    var len = util$4.Buffer.byteLength(value);
     this.uint32(len);
     if (len)
         this._push(writeStringBuffer, len, value);
@@ -6090,12 +6090,12 @@ BufferWriter._configure();
 
 var reader = Reader$1;
 
-var util$5      = requireMinimal();
+var util$3      = requireMinimal();
 
 var BufferReader$1; // cyclic
 
-var LongBits  = util$5.LongBits,
-    utf8      = util$5.utf8;
+var LongBits  = util$3.LongBits,
+    utf8      = util$3.utf8;
 
 /* istanbul ignore next */
 function indexOutOfRange(reader, writeLength) {
@@ -6143,10 +6143,10 @@ var create_array = typeof Uint8Array !== "undefined"
     };
 
 var create = function create() {
-    return util$5.Buffer
+    return util$3.Buffer
         ? function create_buffer_setup(buffer) {
             return (Reader$1.create = function create_buffer(buffer) {
-                return util$5.Buffer.isBuffer(buffer)
+                return util$3.Buffer.isBuffer(buffer)
                     ? new BufferReader$1(buffer)
                     /* istanbul ignore next */
                     : create_array(buffer);
@@ -6165,7 +6165,7 @@ var create = function create() {
  */
 Reader$1.create = create();
 
-Reader$1.prototype._slice = util$5.Array.prototype.subarray || /* istanbul ignore next */ util$5.Array.prototype.slice;
+Reader$1.prototype._slice = util$3.Array.prototype.subarray || /* istanbul ignore next */ util$3.Array.prototype.slice;
 
 /**
  * Reads a varint as an unsigned 32 bit value.
@@ -6364,7 +6364,7 @@ Reader$1.prototype.float = function read_float() {
     if (this.pos + 4 > this.len)
         throw indexOutOfRange(this, 4);
 
-    var value = util$5.float.readFloatLE(this.buf, this.pos);
+    var value = util$3.float.readFloatLE(this.buf, this.pos);
     this.pos += 4;
     return value;
 };
@@ -6380,7 +6380,7 @@ Reader$1.prototype.double = function read_double() {
     if (this.pos + 8 > this.len)
         throw indexOutOfRange(this, 4);
 
-    var value = util$5.float.readDoubleLE(this.buf, this.pos);
+    var value = util$3.float.readDoubleLE(this.buf, this.pos);
     this.pos += 8;
     return value;
 };
@@ -6473,8 +6473,8 @@ Reader$1._configure = function(BufferReader_) {
     Reader$1.create = create();
     BufferReader$1._configure();
 
-    var fn = util$5.Long ? "toLong" : /* istanbul ignore next */ "toNumber";
-    util$5.merge(Reader$1.prototype, {
+    var fn = util$3.Long ? "toLong" : /* istanbul ignore next */ "toNumber";
+    util$3.merge(Reader$1.prototype, {
 
         int64: function read_int64() {
             return readLongVarint.call(this)[fn](false);
@@ -6505,7 +6505,7 @@ var reader_buffer = BufferReader;
 var Reader = reader;
 (BufferReader.prototype = Object.create(Reader.prototype)).constructor = BufferReader;
 
-var util$4 = requireMinimal();
+var util$2 = requireMinimal();
 
 /**
  * Constructs a new buffer reader instance.
@@ -6526,8 +6526,8 @@ function BufferReader(buffer) {
 
 BufferReader._configure = function () {
     /* istanbul ignore else */
-    if (util$4.Buffer)
-        BufferReader.prototype._slice = util$4.Buffer.prototype.slice;
+    if (util$2.Buffer)
+        BufferReader.prototype._slice = util$2.Buffer.prototype.slice;
 };
 
 
@@ -6554,10 +6554,10 @@ var rpc = {};
 
 var service$1 = Service;
 
-var util$3 = requireMinimal();
+var util$1 = requireMinimal();
 
 // Extends EventEmitter
-(Service.prototype = Object.create(util$3.EventEmitter.prototype)).constructor = Service;
+(Service.prototype = Object.create(util$1.EventEmitter.prototype)).constructor = Service;
 
 /**
  * A service method callback as used by {@link rpc.ServiceMethod|ServiceMethod}.
@@ -6597,7 +6597,7 @@ function Service(rpcImpl, requestDelimited, responseDelimited) {
     if (typeof rpcImpl !== "function")
         throw TypeError("rpcImpl must be a function");
 
-    util$3.EventEmitter.call(this);
+    util$1.EventEmitter.call(this);
 
     /**
      * RPC implementation. Becomes `null` once the service is ended.
@@ -6636,7 +6636,7 @@ Service.prototype.rpcCall = function rpcCall(method, requestCtor, responseCtor,
 
     var self = this;
     if (!callback)
-        return util$3.asPromise(rpcCall, self, method, requestCtor, responseCtor, request);
+        return util$1.asPromise(rpcCall, self, method, requestCtor, responseCtor, request);
 
     if (!self.rpcImpl) {
         setTimeout(function() { callback(Error("already ended")); }, 0);
@@ -115209,20 +115209,25 @@ function requireBlowfish () {
 
 cryptoJs.exports;
 
-(function (module, exports) {
-(function (root, factory, undef) {
-		{
-			// CommonJS
-			module.exports = factory(requireCore$1(), requireX64Core(), requireLibTypedarrays(), requireEncUtf16(), requireEncBase64(), requireEncBase64url(), requireMd5(), requireSha1(), requireSha256(), requireSha224(), requireSha512(), requireSha384(), requireSha3(), requireRipemd160(), requireHmac(), requirePbkdf2(), requireEvpkdf(), requireCipherCore(), requireModeCfb(), requireModeCtr(), requireModeCtrGladman(), requireModeOfb(), requireModeEcb(), requirePadAnsix923(), requirePadIso10126(), requirePadIso97971(), requirePadZeropadding(), requirePadNopadding(), requireFormatHex(), requireAes(), requireTripledes(), requireRc4(), requireRabbit(), requireRabbitLegacy(), requireBlowfish());
-		}
-	}(commonjsGlobal$1, function (CryptoJS) {
+var hasRequiredCryptoJs;
 
-		return CryptoJS;
+function requireCryptoJs () {
+	if (hasRequiredCryptoJs) return cryptoJs.exports;
+	hasRequiredCryptoJs = 1;
+	(function (module, exports) {
+(function (root, factory, undef) {
+			{
+				// CommonJS
+				module.exports = factory(requireCore$1(), requireX64Core(), requireLibTypedarrays(), requireEncUtf16(), requireEncBase64(), requireEncBase64url(), requireMd5(), requireSha1(), requireSha256(), requireSha224(), requireSha512(), requireSha384(), requireSha3(), requireRipemd160(), requireHmac(), requirePbkdf2(), requireEvpkdf(), requireCipherCore(), requireModeCfb(), requireModeCtr(), requireModeCtrGladman(), requireModeOfb(), requireModeEcb(), requirePadAnsix923(), requirePadIso10126(), requirePadIso97971(), requirePadZeropadding(), requirePadNopadding(), requireFormatHex(), requireAes(), requireTripledes(), requireRc4(), requireRabbit(), requireRabbitLegacy(), requireBlowfish());
+			}
+		}(commonjsGlobal$1, function (CryptoJS) {
 
-	})); 
-} (cryptoJs, cryptoJs.exports));
+			return CryptoJS;
 
-var cryptoJsExports = cryptoJs.exports;
+		})); 
+	} (cryptoJs, cryptoJs.exports));
+	return cryptoJs.exports;
+}
 
 var utility = {};
 
@@ -117727,826 +117732,858 @@ function requireUtility () {
 	return utility;
 }
 
-const ERROR_MSG_INPUT = 'Input must be an string, Buffer or Uint8Array';
-
-// For convenience, let people hash a string, not just a Uint8Array
-function normalizeInput (input) {
-  let ret;
-  if (input instanceof Uint8Array) {
-    ret = input;
-  } else if (typeof input === 'string') {
-    const encoder = new TextEncoder();
-    ret = encoder.encode(input);
-  } else {
-    throw new Error(ERROR_MSG_INPUT)
-  }
-  return ret
-}
-
-// Converts a Uint8Array to a hexadecimal string
-// For example, toHex([255, 0, 255]) returns "ff00ff"
-function toHex (bytes) {
-  return Array.prototype.map
-    .call(bytes, function (n) {
-      return (n < 16 ? '0' : '') + n.toString(16)
-    })
-    .join('')
-}
-
-// Converts any value in [0...2^32-1] to an 8-character hex string
-function uint32ToHex (val) {
-  return (0x100000000 + val).toString(16).substring(1)
-}
-
-// For debugging: prints out hash state in the same format as the RFC
-// sample computation exactly, so that you can diff
-function debugPrint (label, arr, size) {
-  let msg = '\n' + label + ' = ';
-  for (let i = 0; i < arr.length; i += 2) {
-    if (size === 32) {
-      msg += uint32ToHex(arr[i]).toUpperCase();
-      msg += ' ';
-      msg += uint32ToHex(arr[i + 1]).toUpperCase();
-    } else if (size === 64) {
-      msg += uint32ToHex(arr[i + 1]).toUpperCase();
-      msg += uint32ToHex(arr[i]).toUpperCase();
-    } else throw new Error('Invalid size ' + size)
-    if (i % 6 === 4) {
-      msg += '\n' + new Array(label.length + 4).join(' ');
-    } else if (i < arr.length - 2) {
-      msg += ' ';
-    }
-  }
-  console.log(msg);
-}
-
-// For performance testing: generates N bytes of input, hashes M times
-// Measures and prints MB/second hash performance each time
-function testSpeed (hashFn, N, M) {
-  let startMs = new Date().getTime();
-
-  const input = new Uint8Array(N);
-  for (let i = 0; i < N; i++) {
-    input[i] = i % 256;
-  }
-  const genMs = new Date().getTime();
-  console.log('Generated random input in ' + (genMs - startMs) + 'ms');
-  startMs = genMs;
-
-  for (let i = 0; i < M; i++) {
-    const hashHex = hashFn(input);
-    const hashMs = new Date().getTime();
-    const ms = hashMs - startMs;
-    startMs = hashMs;
-    console.log('Hashed in ' + ms + 'ms: ' + hashHex.substring(0, 20) + '...');
-    console.log(
-      Math.round((N / (1 << 20) / (ms / 1000)) * 100) / 100 + ' MB PER SECOND'
-    );
-  }
-}
-
-var util$2 = {
-  normalizeInput: normalizeInput,
-  toHex: toHex,
-  debugPrint: debugPrint,
-  testSpeed: testSpeed
-};
+var util;
+var hasRequiredUtil;
 
-// Blake2B in pure Javascript
-// Adapted from the reference implementation in RFC7693
-// Ported to Javascript by DC - https://github.com/dcposch
-
-const util$1 = util$2;
-
-// 64-bit unsigned addition
-// Sets v[a,a+1] += v[b,b+1]
-// v should be a Uint32Array
-function ADD64AA (v, a, b) {
-  const o0 = v[a] + v[b];
-  let o1 = v[a + 1] + v[b + 1];
-  if (o0 >= 0x100000000) {
-    o1++;
-  }
-  v[a] = o0;
-  v[a + 1] = o1;
-}
-
-// 64-bit unsigned addition
-// Sets v[a,a+1] += b
-// b0 is the low 32 bits of b, b1 represents the high 32 bits
-function ADD64AC (v, a, b0, b1) {
-  let o0 = v[a] + b0;
-  if (b0 < 0) {
-    o0 += 0x100000000;
-  }
-  let o1 = v[a + 1] + b1;
-  if (o0 >= 0x100000000) {
-    o1++;
-  }
-  v[a] = o0;
-  v[a + 1] = o1;
-}
-
-// Little-endian byte access
-function B2B_GET32 (arr, i) {
-  return arr[i] ^ (arr[i + 1] << 8) ^ (arr[i + 2] << 16) ^ (arr[i + 3] << 24)
-}
-
-// G Mixing function
-// The ROTRs are inlined for speed
-function B2B_G (a, b, c, d, ix, iy) {
-  const x0 = m$1[ix];
-  const x1 = m$1[ix + 1];
-  const y0 = m$1[iy];
-  const y1 = m$1[iy + 1];
-
-  ADD64AA(v$1, a, b); // v[a,a+1] += v[b,b+1] ... in JS we must store a uint64 as two uint32s
-  ADD64AC(v$1, a, x0, x1); // v[a, a+1] += x ... x0 is the low 32 bits of x, x1 is the high 32 bits
-
-  // v[d,d+1] = (v[d,d+1] xor v[a,a+1]) rotated to the right by 32 bits
-  let xor0 = v$1[d] ^ v$1[a];
-  let xor1 = v$1[d + 1] ^ v$1[a + 1];
-  v$1[d] = xor1;
-  v$1[d + 1] = xor0;
-
-  ADD64AA(v$1, c, d);
-
-  // v[b,b+1] = (v[b,b+1] xor v[c,c+1]) rotated right by 24 bits
-  xor0 = v$1[b] ^ v$1[c];
-  xor1 = v$1[b + 1] ^ v$1[c + 1];
-  v$1[b] = (xor0 >>> 24) ^ (xor1 << 8);
-  v$1[b + 1] = (xor1 >>> 24) ^ (xor0 << 8);
-
-  ADD64AA(v$1, a, b);
-  ADD64AC(v$1, a, y0, y1);
-
-  // v[d,d+1] = (v[d,d+1] xor v[a,a+1]) rotated right by 16 bits
-  xor0 = v$1[d] ^ v$1[a];
-  xor1 = v$1[d + 1] ^ v$1[a + 1];
-  v$1[d] = (xor0 >>> 16) ^ (xor1 << 16);
-  v$1[d + 1] = (xor1 >>> 16) ^ (xor0 << 16);
-
-  ADD64AA(v$1, c, d);
-
-  // v[b,b+1] = (v[b,b+1] xor v[c,c+1]) rotated right by 63 bits
-  xor0 = v$1[b] ^ v$1[c];
-  xor1 = v$1[b + 1] ^ v$1[c + 1];
-  v$1[b] = (xor1 >>> 31) ^ (xor0 << 1);
-  v$1[b + 1] = (xor0 >>> 31) ^ (xor1 << 1);
-}
-
-// Initialization Vector
-const BLAKE2B_IV32 = new Uint32Array([
-  0xf3bcc908, 0x6a09e667, 0x84caa73b, 0xbb67ae85, 0xfe94f82b, 0x3c6ef372,
-  0x5f1d36f1, 0xa54ff53a, 0xade682d1, 0x510e527f, 0x2b3e6c1f, 0x9b05688c,
-  0xfb41bd6b, 0x1f83d9ab, 0x137e2179, 0x5be0cd19
-]);
+function requireUtil () {
+	if (hasRequiredUtil) return util;
+	hasRequiredUtil = 1;
+	const ERROR_MSG_INPUT = 'Input must be an string, Buffer or Uint8Array';
 
-const SIGMA8 = [
-  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 14, 10, 4, 8, 9, 15, 13,
-  6, 1, 12, 0, 2, 11, 7, 5, 3, 11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1,
-  9, 4, 7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8, 9, 0, 5, 7, 2, 4,
-  10, 15, 14, 1, 11, 12, 6, 8, 3, 13, 2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5,
-  15, 14, 1, 9, 12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11, 13, 11, 7,
-  14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10, 6, 15, 14, 9, 11, 3, 0, 8, 12, 2,
-  13, 7, 1, 4, 10, 5, 10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13, 0, 0,
-  1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 14, 10, 4, 8, 9, 15, 13, 6,
-  1, 12, 0, 2, 11, 7, 5, 3
-];
+	// For convenience, let people hash a string, not just a Uint8Array
+	function normalizeInput (input) {
+	  let ret;
+	  if (input instanceof Uint8Array) {
+	    ret = input;
+	  } else if (typeof input === 'string') {
+	    const encoder = new TextEncoder();
+	    ret = encoder.encode(input);
+	  } else {
+	    throw new Error(ERROR_MSG_INPUT)
+	  }
+	  return ret
+	}
+
+	// Converts a Uint8Array to a hexadecimal string
+	// For example, toHex([255, 0, 255]) returns "ff00ff"
+	function toHex (bytes) {
+	  return Array.prototype.map
+	    .call(bytes, function (n) {
+	      return (n < 16 ? '0' : '') + n.toString(16)
+	    })
+	    .join('')
+	}
+
+	// Converts any value in [0...2^32-1] to an 8-character hex string
+	function uint32ToHex (val) {
+	  return (0x100000000 + val).toString(16).substring(1)
+	}
+
+	// For debugging: prints out hash state in the same format as the RFC
+	// sample computation exactly, so that you can diff
+	function debugPrint (label, arr, size) {
+	  let msg = '\n' + label + ' = ';
+	  for (let i = 0; i < arr.length; i += 2) {
+	    if (size === 32) {
+	      msg += uint32ToHex(arr[i]).toUpperCase();
+	      msg += ' ';
+	      msg += uint32ToHex(arr[i + 1]).toUpperCase();
+	    } else if (size === 64) {
+	      msg += uint32ToHex(arr[i + 1]).toUpperCase();
+	      msg += uint32ToHex(arr[i]).toUpperCase();
+	    } else throw new Error('Invalid size ' + size)
+	    if (i % 6 === 4) {
+	      msg += '\n' + new Array(label.length + 4).join(' ');
+	    } else if (i < arr.length - 2) {
+	      msg += ' ';
+	    }
+	  }
+	  console.log(msg);
+	}
 
-// These are offsets into a uint64 buffer.
-// Multiply them all by 2 to make them offsets into a uint32 buffer,
-// because this is Javascript and we don't have uint64s
-const SIGMA82 = new Uint8Array(
-  SIGMA8.map(function (x) {
-    return x * 2
-  })
-);
+	// For performance testing: generates N bytes of input, hashes M times
+	// Measures and prints MB/second hash performance each time
+	function testSpeed (hashFn, N, M) {
+	  let startMs = new Date().getTime();
 
-// Compression function. 'last' flag indicates last block.
-// Note we're representing 16 uint64s as 32 uint32s
-const v$1 = new Uint32Array(32);
-const m$1 = new Uint32Array(32);
-function blake2bCompress (ctx, last) {
-  let i = 0;
-
-  // init work variables
-  for (i = 0; i < 16; i++) {
-    v$1[i] = ctx.h[i];
-    v$1[i + 16] = BLAKE2B_IV32[i];
-  }
-
-  // low 64 bits of offset
-  v$1[24] = v$1[24] ^ ctx.t;
-  v$1[25] = v$1[25] ^ (ctx.t / 0x100000000);
-  // high 64 bits not supported, offset may not be higher than 2**53-1
-
-  // last block flag set ?
-  if (last) {
-    v$1[28] = ~v$1[28];
-    v$1[29] = ~v$1[29];
-  }
-
-  // get little-endian words
-  for (i = 0; i < 32; i++) {
-    m$1[i] = B2B_GET32(ctx.b, 4 * i);
-  }
-
-  // twelve rounds of mixing
-  // uncomment the DebugPrint calls to log the computation
-  // and match the RFC sample documentation
-  // util.debugPrint('          m[16]', m, 64)
-  for (i = 0; i < 12; i++) {
-    // util.debugPrint('   (i=' + (i < 10 ? ' ' : '') + i + ') v[16]', v, 64)
-    B2B_G(0, 8, 16, 24, SIGMA82[i * 16 + 0], SIGMA82[i * 16 + 1]);
-    B2B_G(2, 10, 18, 26, SIGMA82[i * 16 + 2], SIGMA82[i * 16 + 3]);
-    B2B_G(4, 12, 20, 28, SIGMA82[i * 16 + 4], SIGMA82[i * 16 + 5]);
-    B2B_G(6, 14, 22, 30, SIGMA82[i * 16 + 6], SIGMA82[i * 16 + 7]);
-    B2B_G(0, 10, 20, 30, SIGMA82[i * 16 + 8], SIGMA82[i * 16 + 9]);
-    B2B_G(2, 12, 22, 24, SIGMA82[i * 16 + 10], SIGMA82[i * 16 + 11]);
-    B2B_G(4, 14, 16, 26, SIGMA82[i * 16 + 12], SIGMA82[i * 16 + 13]);
-    B2B_G(6, 8, 18, 28, SIGMA82[i * 16 + 14], SIGMA82[i * 16 + 15]);
-  }
-  // util.debugPrint('   (i=12) v[16]', v, 64)
-
-  for (i = 0; i < 16; i++) {
-    ctx.h[i] = ctx.h[i] ^ v$1[i] ^ v$1[i + 16];
-  }
-  // util.debugPrint('h[8]', ctx.h, 64)
-}
-
-// reusable parameterBlock
-const parameterBlock = new Uint8Array([
-  0,
-  0,
-  0,
-  0, //  0: outlen, keylen, fanout, depth
-  0,
-  0,
-  0,
-  0, //  4: leaf length, sequential mode
-  0,
-  0,
-  0,
-  0, //  8: node offset
-  0,
-  0,
-  0,
-  0, // 12: node offset
-  0,
-  0,
-  0,
-  0, // 16: node depth, inner length, rfu
-  0,
-  0,
-  0,
-  0, // 20: rfu
-  0,
-  0,
-  0,
-  0, // 24: rfu
-  0,
-  0,
-  0,
-  0, // 28: rfu
-  0,
-  0,
-  0,
-  0, // 32: salt
-  0,
-  0,
-  0,
-  0, // 36: salt
-  0,
-  0,
-  0,
-  0, // 40: salt
-  0,
-  0,
-  0,
-  0, // 44: salt
-  0,
-  0,
-  0,
-  0, // 48: personal
-  0,
-  0,
-  0,
-  0, // 52: personal
-  0,
-  0,
-  0,
-  0, // 56: personal
-  0,
-  0,
-  0,
-  0 // 60: personal
-]);
+	  const input = new Uint8Array(N);
+	  for (let i = 0; i < N; i++) {
+	    input[i] = i % 256;
+	  }
+	  const genMs = new Date().getTime();
+	  console.log('Generated random input in ' + (genMs - startMs) + 'ms');
+	  startMs = genMs;
+
+	  for (let i = 0; i < M; i++) {
+	    const hashHex = hashFn(input);
+	    const hashMs = new Date().getTime();
+	    const ms = hashMs - startMs;
+	    startMs = hashMs;
+	    console.log('Hashed in ' + ms + 'ms: ' + hashHex.substring(0, 20) + '...');
+	    console.log(
+	      Math.round((N / (1 << 20) / (ms / 1000)) * 100) / 100 + ' MB PER SECOND'
+	    );
+	  }
+	}
 
-// Creates a BLAKE2b hashing context
-// Requires an output length between 1 and 64 bytes
-// Takes an optional Uint8Array key
-// Takes an optinal Uint8Array salt
-// Takes an optinal Uint8Array personal
-function blake2bInit (outlen, key, salt, personal) {
-  if (outlen === 0 || outlen > 64) {
-    throw new Error('Illegal output length, expected 0 < length <= 64')
-  }
-  if (key && key.length > 64) {
-    throw new Error('Illegal key, expected Uint8Array with 0 < length <= 64')
-  }
-  if (salt && salt.length !== 16) {
-    throw new Error('Illegal salt, expected Uint8Array with length is 16')
-  }
-  if (personal && personal.length !== 16) {
-    throw new Error('Illegal personal, expected Uint8Array with length is 16')
-  }
-
-  // state, 'param block'
-  const ctx = {
-    b: new Uint8Array(128),
-    h: new Uint32Array(16),
-    t: 0, // input count
-    c: 0, // pointer within buffer
-    outlen: outlen // output length in bytes
-  };
-
-  // initialize parameterBlock before usage
-  parameterBlock.fill(0);
-  parameterBlock[0] = outlen;
-  if (key) parameterBlock[1] = key.length;
-  parameterBlock[2] = 1; // fanout
-  parameterBlock[3] = 1; // depth
-  if (salt) parameterBlock.set(salt, 32);
-  if (personal) parameterBlock.set(personal, 48);
-
-  // initialize hash state
-  for (let i = 0; i < 16; i++) {
-    ctx.h[i] = BLAKE2B_IV32[i] ^ B2B_GET32(parameterBlock, i * 4);
-  }
-
-  // key the hash, if applicable
-  if (key) {
-    blake2bUpdate(ctx, key);
-    // at the end
-    ctx.c = 128;
-  }
-
-  return ctx
-}
-
-// Updates a BLAKE2b streaming hash
-// Requires hash context and Uint8Array (byte array)
-function blake2bUpdate (ctx, input) {
-  for (let i = 0; i < input.length; i++) {
-    if (ctx.c === 128) {
-      // buffer full ?
-      ctx.t += ctx.c; // add counters
-      blake2bCompress(ctx, false); // compress (not last)
-      ctx.c = 0; // counter to zero
-    }
-    ctx.b[ctx.c++] = input[i];
-  }
-}
-
-// Completes a BLAKE2b streaming hash
-// Returns a Uint8Array containing the message digest
-function blake2bFinal (ctx) {
-  ctx.t += ctx.c; // mark last block offset
-
-  while (ctx.c < 128) {
-    // fill up with zeros
-    ctx.b[ctx.c++] = 0;
-  }
-  blake2bCompress(ctx, true); // final block flag = 1
-
-  // little endian convert and store
-  const out = new Uint8Array(ctx.outlen);
-  for (let i = 0; i < ctx.outlen; i++) {
-    out[i] = ctx.h[i >> 2] >> (8 * (i & 3));
-  }
-  return out
-}
-
-// Computes the BLAKE2B hash of a string or byte array, and returns a Uint8Array
-//
-// Returns a n-byte Uint8Array
-//
-// Parameters:
-// - input - the input bytes, as a string, Buffer or Uint8Array
-// - key - optional key Uint8Array, up to 64 bytes
-// - outlen - optional output length in bytes, default 64
-// - salt - optional salt bytes, string, Buffer or Uint8Array
-// - personal - optional personal bytes, string, Buffer or Uint8Array
-function blake2b (input, key, outlen, salt, personal) {
-  // preprocess inputs
-  outlen = outlen || 64;
-  input = util$1.normalizeInput(input);
-  if (salt) {
-    salt = util$1.normalizeInput(salt);
-  }
-  if (personal) {
-    personal = util$1.normalizeInput(personal);
-  }
-
-  // do the math
-  const ctx = blake2bInit(outlen, key, salt, personal);
-  blake2bUpdate(ctx, input);
-  return blake2bFinal(ctx)
-}
-
-// Computes the BLAKE2B hash of a string or byte array
-//
-// Returns an n-byte hash in hex, all lowercase
-//
-// Parameters:
-// - input - the input bytes, as a string, Buffer, or Uint8Array
-// - key - optional key Uint8Array, up to 64 bytes
-// - outlen - optional output length in bytes, default 64
-// - salt - optional salt bytes, string, Buffer or Uint8Array
-// - personal - optional personal bytes, string, Buffer or Uint8Array
-function blake2bHex (input, key, outlen, salt, personal) {
-  const output = blake2b(input, key, outlen, salt, personal);
-  return util$1.toHex(output)
-}
-
-var blake2b_1 = {
-  blake2b: blake2b,
-  blake2bHex: blake2bHex,
-  blake2bInit: blake2bInit,
-  blake2bUpdate: blake2bUpdate,
-  blake2bFinal: blake2bFinal
-};
+	util = {
+	  normalizeInput: normalizeInput,
+	  toHex: toHex,
+	  debugPrint: debugPrint,
+	  testSpeed: testSpeed
+	};
+	return util;
+}
 
-// BLAKE2s hash function in pure Javascript
-// Adapted from the reference implementation in RFC7693
-// Ported to Javascript by DC - https://github.com/dcposch
-
-const util = util$2;
-
-// Little-endian byte access.
-// Expects a Uint8Array and an index
-// Returns the little-endian uint32 at v[i..i+3]
-function B2S_GET32 (v, i) {
-  return v[i] ^ (v[i + 1] << 8) ^ (v[i + 2] << 16) ^ (v[i + 3] << 24)
-}
-
-// Mixing function G.
-function B2S_G (a, b, c, d, x, y) {
-  v[a] = v[a] + v[b] + x;
-  v[d] = ROTR32(v[d] ^ v[a], 16);
-  v[c] = v[c] + v[d];
-  v[b] = ROTR32(v[b] ^ v[c], 12);
-  v[a] = v[a] + v[b] + y;
-  v[d] = ROTR32(v[d] ^ v[a], 8);
-  v[c] = v[c] + v[d];
-  v[b] = ROTR32(v[b] ^ v[c], 7);
-}
-
-// 32-bit right rotation
-// x should be a uint32
-// y must be between 1 and 31, inclusive
-function ROTR32 (x, y) {
-  return (x >>> y) ^ (x << (32 - y))
-}
-
-// Initialization Vector.
-const BLAKE2S_IV = new Uint32Array([
-  0x6a09e667,
-  0xbb67ae85,
-  0x3c6ef372,
-  0xa54ff53a,
-  0x510e527f,
-  0x9b05688c,
-  0x1f83d9ab,
-  0x5be0cd19
-]);
+var blake2b_1;
+var hasRequiredBlake2b;
 
-const SIGMA = new Uint8Array([
-  0,
-  1,
-  2,
-  3,
-  4,
-  5,
-  6,
-  7,
-  8,
-  9,
-  10,
-  11,
-  12,
-  13,
-  14,
-  15,
-  14,
-  10,
-  4,
-  8,
-  9,
-  15,
-  13,
-  6,
-  1,
-  12,
-  0,
-  2,
-  11,
-  7,
-  5,
-  3,
-  11,
-  8,
-  12,
-  0,
-  5,
-  2,
-  15,
-  13,
-  10,
-  14,
-  3,
-  6,
-  7,
-  1,
-  9,
-  4,
-  7,
-  9,
-  3,
-  1,
-  13,
-  12,
-  11,
-  14,
-  2,
-  6,
-  5,
-  10,
-  4,
-  0,
-  15,
-  8,
-  9,
-  0,
-  5,
-  7,
-  2,
-  4,
-  10,
-  15,
-  14,
-  1,
-  11,
-  12,
-  6,
-  8,
-  3,
-  13,
-  2,
-  12,
-  6,
-  10,
-  0,
-  11,
-  8,
-  3,
-  4,
-  13,
-  7,
-  5,
-  15,
-  14,
-  1,
-  9,
-  12,
-  5,
-  1,
-  15,
-  14,
-  13,
-  4,
-  10,
-  0,
-  7,
-  6,
-  3,
-  9,
-  2,
-  8,
-  11,
-  13,
-  11,
-  7,
-  14,
-  12,
-  1,
-  3,
-  9,
-  5,
-  0,
-  15,
-  4,
-  8,
-  6,
-  2,
-  10,
-  6,
-  15,
-  14,
-  9,
-  11,
-  3,
-  0,
-  8,
-  12,
-  2,
-  13,
-  7,
-  1,
-  4,
-  10,
-  5,
-  10,
-  2,
-  8,
-  4,
-  7,
-  6,
-  1,
-  5,
-  15,
-  11,
-  9,
-  14,
-  3,
-  12,
-  13,
-  0
-]);
+function requireBlake2b () {
+	if (hasRequiredBlake2b) return blake2b_1;
+	hasRequiredBlake2b = 1;
+	// Blake2B in pure Javascript
+	// Adapted from the reference implementation in RFC7693
+	// Ported to Javascript by DC - https://github.com/dcposch
 
-// Compression function. "last" flag indicates last block
-const v = new Uint32Array(16);
-const m = new Uint32Array(16);
-function blake2sCompress (ctx, last) {
-  let i = 0;
-  for (i = 0; i < 8; i++) {
-    // init work variables
-    v[i] = ctx.h[i];
-    v[i + 8] = BLAKE2S_IV[i];
-  }
-
-  v[12] ^= ctx.t; // low 32 bits of offset
-  v[13] ^= ctx.t / 0x100000000; // high 32 bits
-  if (last) {
-    // last block flag set ?
-    v[14] = ~v[14];
-  }
-
-  for (i = 0; i < 16; i++) {
-    // get little-endian words
-    m[i] = B2S_GET32(ctx.b, 4 * i);
-  }
-
-  // ten rounds of mixing
-  // uncomment the DebugPrint calls to log the computation
-  // and match the RFC sample documentation
-  // util.debugPrint('          m[16]', m, 32)
-  for (i = 0; i < 10; i++) {
-    // util.debugPrint('   (i=' + i + ')  v[16]', v, 32)
-    B2S_G(0, 4, 8, 12, m[SIGMA[i * 16 + 0]], m[SIGMA[i * 16 + 1]]);
-    B2S_G(1, 5, 9, 13, m[SIGMA[i * 16 + 2]], m[SIGMA[i * 16 + 3]]);
-    B2S_G(2, 6, 10, 14, m[SIGMA[i * 16 + 4]], m[SIGMA[i * 16 + 5]]);
-    B2S_G(3, 7, 11, 15, m[SIGMA[i * 16 + 6]], m[SIGMA[i * 16 + 7]]);
-    B2S_G(0, 5, 10, 15, m[SIGMA[i * 16 + 8]], m[SIGMA[i * 16 + 9]]);
-    B2S_G(1, 6, 11, 12, m[SIGMA[i * 16 + 10]], m[SIGMA[i * 16 + 11]]);
-    B2S_G(2, 7, 8, 13, m[SIGMA[i * 16 + 12]], m[SIGMA[i * 16 + 13]]);
-    B2S_G(3, 4, 9, 14, m[SIGMA[i * 16 + 14]], m[SIGMA[i * 16 + 15]]);
-  }
-  // util.debugPrint('   (i=10) v[16]', v, 32)
-
-  for (i = 0; i < 8; i++) {
-    ctx.h[i] ^= v[i] ^ v[i + 8];
-  }
-  // util.debugPrint('h[8]', ctx.h, 32)
-}
-
-// Creates a BLAKE2s hashing context
-// Requires an output length between 1 and 32 bytes
-// Takes an optional Uint8Array key
-function blake2sInit (outlen, key) {
-  if (!(outlen > 0 && outlen <= 32)) {
-    throw new Error('Incorrect output length, should be in [1, 32]')
-  }
-  const keylen = key ? key.length : 0;
-  if (key && !(keylen > 0 && keylen <= 32)) {
-    throw new Error('Incorrect key length, should be in [1, 32]')
-  }
-
-  const ctx = {
-    h: new Uint32Array(BLAKE2S_IV), // hash state
-    b: new Uint8Array(64), // input block
-    c: 0, // pointer within block
-    t: 0, // input count
-    outlen: outlen // output length in bytes
-  };
-  ctx.h[0] ^= 0x01010000 ^ (keylen << 8) ^ outlen;
-
-  if (keylen > 0) {
-    blake2sUpdate(ctx, key);
-    ctx.c = 64; // at the end
-  }
-
-  return ctx
-}
-
-// Updates a BLAKE2s streaming hash
-// Requires hash context and Uint8Array (byte array)
-function blake2sUpdate (ctx, input) {
-  for (let i = 0; i < input.length; i++) {
-    if (ctx.c === 64) {
-      // buffer full ?
-      ctx.t += ctx.c; // add counters
-      blake2sCompress(ctx, false); // compress (not last)
-      ctx.c = 0; // counter to zero
-    }
-    ctx.b[ctx.c++] = input[i];
-  }
-}
-
-// Completes a BLAKE2s streaming hash
-// Returns a Uint8Array containing the message digest
-function blake2sFinal (ctx) {
-  ctx.t += ctx.c; // mark last block offset
-  while (ctx.c < 64) {
-    // fill up with zeros
-    ctx.b[ctx.c++] = 0;
-  }
-  blake2sCompress(ctx, true); // final block flag = 1
-
-  // little endian convert and store
-  const out = new Uint8Array(ctx.outlen);
-  for (let i = 0; i < ctx.outlen; i++) {
-    out[i] = (ctx.h[i >> 2] >> (8 * (i & 3))) & 0xff;
-  }
-  return out
-}
-
-// Computes the BLAKE2S hash of a string or byte array, and returns a Uint8Array
-//
-// Returns a n-byte Uint8Array
-//
-// Parameters:
-// - input - the input bytes, as a string, Buffer, or Uint8Array
-// - key - optional key Uint8Array, up to 32 bytes
-// - outlen - optional output length in bytes, default 64
-function blake2s (input, key, outlen) {
-  // preprocess inputs
-  outlen = outlen || 32;
-  input = util.normalizeInput(input);
-
-  // do the math
-  const ctx = blake2sInit(outlen, key);
-  blake2sUpdate(ctx, input);
-  return blake2sFinal(ctx)
-}
-
-// Computes the BLAKE2S hash of a string or byte array
-//
-// Returns an n-byte hash in hex, all lowercase
-//
-// Parameters:
-// - input - the input bytes, as a string, Buffer, or Uint8Array
-// - key - optional key Uint8Array, up to 32 bytes
-// - outlen - optional output length in bytes, default 64
-function blake2sHex (input, key, outlen) {
-  const output = blake2s(input, key, outlen);
-  return util.toHex(output)
-}
-
-var blake2s_1 = {
-  blake2s: blake2s,
-  blake2sHex: blake2sHex,
-  blake2sInit: blake2sInit,
-  blake2sUpdate: blake2sUpdate,
-  blake2sFinal: blake2sFinal
-};
+	const util = requireUtil();
 
-const b2b = blake2b_1;
-const b2s = blake2s_1;
-
-var blakejs = {
-  blake2b: b2b.blake2b,
-  blake2bHex: b2b.blake2bHex,
-  blake2bInit: b2b.blake2bInit,
-  blake2bUpdate: b2b.blake2bUpdate,
-  blake2bFinal: b2b.blake2bFinal,
-  blake2s: b2s.blake2s,
-  blake2sHex: b2s.blake2sHex,
-  blake2sInit: b2s.blake2sInit,
-  blake2sUpdate: b2s.blake2sUpdate,
-  blake2sFinal: b2s.blake2sFinal
-};
+	// 64-bit unsigned addition
+	// Sets v[a,a+1] += v[b,b+1]
+	// v should be a Uint32Array
+	function ADD64AA (v, a, b) {
+	  const o0 = v[a] + v[b];
+	  let o1 = v[a + 1] + v[b + 1];
+	  if (o0 >= 0x100000000) {
+	    o1++;
+	  }
+	  v[a] = o0;
+	  v[a + 1] = o1;
+	}
+
+	// 64-bit unsigned addition
+	// Sets v[a,a+1] += b
+	// b0 is the low 32 bits of b, b1 represents the high 32 bits
+	function ADD64AC (v, a, b0, b1) {
+	  let o0 = v[a] + b0;
+	  if (b0 < 0) {
+	    o0 += 0x100000000;
+	  }
+	  let o1 = v[a + 1] + b1;
+	  if (o0 >= 0x100000000) {
+	    o1++;
+	  }
+	  v[a] = o0;
+	  v[a + 1] = o1;
+	}
+
+	// Little-endian byte access
+	function B2B_GET32 (arr, i) {
+	  return arr[i] ^ (arr[i + 1] << 8) ^ (arr[i + 2] << 16) ^ (arr[i + 3] << 24)
+	}
+
+	// G Mixing function
+	// The ROTRs are inlined for speed
+	function B2B_G (a, b, c, d, ix, iy) {
+	  const x0 = m[ix];
+	  const x1 = m[ix + 1];
+	  const y0 = m[iy];
+	  const y1 = m[iy + 1];
+
+	  ADD64AA(v, a, b); // v[a,a+1] += v[b,b+1] ... in JS we must store a uint64 as two uint32s
+	  ADD64AC(v, a, x0, x1); // v[a, a+1] += x ... x0 is the low 32 bits of x, x1 is the high 32 bits
+
+	  // v[d,d+1] = (v[d,d+1] xor v[a,a+1]) rotated to the right by 32 bits
+	  let xor0 = v[d] ^ v[a];
+	  let xor1 = v[d + 1] ^ v[a + 1];
+	  v[d] = xor1;
+	  v[d + 1] = xor0;
+
+	  ADD64AA(v, c, d);
+
+	  // v[b,b+1] = (v[b,b+1] xor v[c,c+1]) rotated right by 24 bits
+	  xor0 = v[b] ^ v[c];
+	  xor1 = v[b + 1] ^ v[c + 1];
+	  v[b] = (xor0 >>> 24) ^ (xor1 << 8);
+	  v[b + 1] = (xor1 >>> 24) ^ (xor0 << 8);
+
+	  ADD64AA(v, a, b);
+	  ADD64AC(v, a, y0, y1);
+
+	  // v[d,d+1] = (v[d,d+1] xor v[a,a+1]) rotated right by 16 bits
+	  xor0 = v[d] ^ v[a];
+	  xor1 = v[d + 1] ^ v[a + 1];
+	  v[d] = (xor0 >>> 16) ^ (xor1 << 16);
+	  v[d + 1] = (xor1 >>> 16) ^ (xor0 << 16);
+
+	  ADD64AA(v, c, d);
+
+	  // v[b,b+1] = (v[b,b+1] xor v[c,c+1]) rotated right by 63 bits
+	  xor0 = v[b] ^ v[c];
+	  xor1 = v[b + 1] ^ v[c + 1];
+	  v[b] = (xor1 >>> 31) ^ (xor0 << 1);
+	  v[b + 1] = (xor0 >>> 31) ^ (xor1 << 1);
+	}
+
+	// Initialization Vector
+	const BLAKE2B_IV32 = new Uint32Array([
+	  0xf3bcc908, 0x6a09e667, 0x84caa73b, 0xbb67ae85, 0xfe94f82b, 0x3c6ef372,
+	  0x5f1d36f1, 0xa54ff53a, 0xade682d1, 0x510e527f, 0x2b3e6c1f, 0x9b05688c,
+	  0xfb41bd6b, 0x1f83d9ab, 0x137e2179, 0x5be0cd19
+	]);
+
+	const SIGMA8 = [
+	  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 14, 10, 4, 8, 9, 15, 13,
+	  6, 1, 12, 0, 2, 11, 7, 5, 3, 11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1,
+	  9, 4, 7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8, 9, 0, 5, 7, 2, 4,
+	  10, 15, 14, 1, 11, 12, 6, 8, 3, 13, 2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5,
+	  15, 14, 1, 9, 12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11, 13, 11, 7,
+	  14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10, 6, 15, 14, 9, 11, 3, 0, 8, 12, 2,
+	  13, 7, 1, 4, 10, 5, 10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13, 0, 0,
+	  1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 14, 10, 4, 8, 9, 15, 13, 6,
+	  1, 12, 0, 2, 11, 7, 5, 3
+	];
+
+	// These are offsets into a uint64 buffer.
+	// Multiply them all by 2 to make them offsets into a uint32 buffer,
+	// because this is Javascript and we don't have uint64s
+	const SIGMA82 = new Uint8Array(
+	  SIGMA8.map(function (x) {
+	    return x * 2
+	  })
+	);
+
+	// Compression function. 'last' flag indicates last block.
+	// Note we're representing 16 uint64s as 32 uint32s
+	const v = new Uint32Array(32);
+	const m = new Uint32Array(32);
+	function blake2bCompress (ctx, last) {
+	  let i = 0;
+
+	  // init work variables
+	  for (i = 0; i < 16; i++) {
+	    v[i] = ctx.h[i];
+	    v[i + 16] = BLAKE2B_IV32[i];
+	  }
+
+	  // low 64 bits of offset
+	  v[24] = v[24] ^ ctx.t;
+	  v[25] = v[25] ^ (ctx.t / 0x100000000);
+	  // high 64 bits not supported, offset may not be higher than 2**53-1
+
+	  // last block flag set ?
+	  if (last) {
+	    v[28] = ~v[28];
+	    v[29] = ~v[29];
+	  }
+
+	  // get little-endian words
+	  for (i = 0; i < 32; i++) {
+	    m[i] = B2B_GET32(ctx.b, 4 * i);
+	  }
+
+	  // twelve rounds of mixing
+	  // uncomment the DebugPrint calls to log the computation
+	  // and match the RFC sample documentation
+	  // util.debugPrint('          m[16]', m, 64)
+	  for (i = 0; i < 12; i++) {
+	    // util.debugPrint('   (i=' + (i < 10 ? ' ' : '') + i + ') v[16]', v, 64)
+	    B2B_G(0, 8, 16, 24, SIGMA82[i * 16 + 0], SIGMA82[i * 16 + 1]);
+	    B2B_G(2, 10, 18, 26, SIGMA82[i * 16 + 2], SIGMA82[i * 16 + 3]);
+	    B2B_G(4, 12, 20, 28, SIGMA82[i * 16 + 4], SIGMA82[i * 16 + 5]);
+	    B2B_G(6, 14, 22, 30, SIGMA82[i * 16 + 6], SIGMA82[i * 16 + 7]);
+	    B2B_G(0, 10, 20, 30, SIGMA82[i * 16 + 8], SIGMA82[i * 16 + 9]);
+	    B2B_G(2, 12, 22, 24, SIGMA82[i * 16 + 10], SIGMA82[i * 16 + 11]);
+	    B2B_G(4, 14, 16, 26, SIGMA82[i * 16 + 12], SIGMA82[i * 16 + 13]);
+	    B2B_G(6, 8, 18, 28, SIGMA82[i * 16 + 14], SIGMA82[i * 16 + 15]);
+	  }
+	  // util.debugPrint('   (i=12) v[16]', v, 64)
+
+	  for (i = 0; i < 16; i++) {
+	    ctx.h[i] = ctx.h[i] ^ v[i] ^ v[i + 16];
+	  }
+	  // util.debugPrint('h[8]', ctx.h, 64)
+	}
+
+	// reusable parameterBlock
+	const parameterBlock = new Uint8Array([
+	  0,
+	  0,
+	  0,
+	  0, //  0: outlen, keylen, fanout, depth
+	  0,
+	  0,
+	  0,
+	  0, //  4: leaf length, sequential mode
+	  0,
+	  0,
+	  0,
+	  0, //  8: node offset
+	  0,
+	  0,
+	  0,
+	  0, // 12: node offset
+	  0,
+	  0,
+	  0,
+	  0, // 16: node depth, inner length, rfu
+	  0,
+	  0,
+	  0,
+	  0, // 20: rfu
+	  0,
+	  0,
+	  0,
+	  0, // 24: rfu
+	  0,
+	  0,
+	  0,
+	  0, // 28: rfu
+	  0,
+	  0,
+	  0,
+	  0, // 32: salt
+	  0,
+	  0,
+	  0,
+	  0, // 36: salt
+	  0,
+	  0,
+	  0,
+	  0, // 40: salt
+	  0,
+	  0,
+	  0,
+	  0, // 44: salt
+	  0,
+	  0,
+	  0,
+	  0, // 48: personal
+	  0,
+	  0,
+	  0,
+	  0, // 52: personal
+	  0,
+	  0,
+	  0,
+	  0, // 56: personal
+	  0,
+	  0,
+	  0,
+	  0 // 60: personal
+	]);
+
+	// Creates a BLAKE2b hashing context
+	// Requires an output length between 1 and 64 bytes
+	// Takes an optional Uint8Array key
+	// Takes an optinal Uint8Array salt
+	// Takes an optinal Uint8Array personal
+	function blake2bInit (outlen, key, salt, personal) {
+	  if (outlen === 0 || outlen > 64) {
+	    throw new Error('Illegal output length, expected 0 < length <= 64')
+	  }
+	  if (key && key.length > 64) {
+	    throw new Error('Illegal key, expected Uint8Array with 0 < length <= 64')
+	  }
+	  if (salt && salt.length !== 16) {
+	    throw new Error('Illegal salt, expected Uint8Array with length is 16')
+	  }
+	  if (personal && personal.length !== 16) {
+	    throw new Error('Illegal personal, expected Uint8Array with length is 16')
+	  }
+
+	  // state, 'param block'
+	  const ctx = {
+	    b: new Uint8Array(128),
+	    h: new Uint32Array(16),
+	    t: 0, // input count
+	    c: 0, // pointer within buffer
+	    outlen: outlen // output length in bytes
+	  };
+
+	  // initialize parameterBlock before usage
+	  parameterBlock.fill(0);
+	  parameterBlock[0] = outlen;
+	  if (key) parameterBlock[1] = key.length;
+	  parameterBlock[2] = 1; // fanout
+	  parameterBlock[3] = 1; // depth
+	  if (salt) parameterBlock.set(salt, 32);
+	  if (personal) parameterBlock.set(personal, 48);
+
+	  // initialize hash state
+	  for (let i = 0; i < 16; i++) {
+	    ctx.h[i] = BLAKE2B_IV32[i] ^ B2B_GET32(parameterBlock, i * 4);
+	  }
+
+	  // key the hash, if applicable
+	  if (key) {
+	    blake2bUpdate(ctx, key);
+	    // at the end
+	    ctx.c = 128;
+	  }
+
+	  return ctx
+	}
+
+	// Updates a BLAKE2b streaming hash
+	// Requires hash context and Uint8Array (byte array)
+	function blake2bUpdate (ctx, input) {
+	  for (let i = 0; i < input.length; i++) {
+	    if (ctx.c === 128) {
+	      // buffer full ?
+	      ctx.t += ctx.c; // add counters
+	      blake2bCompress(ctx, false); // compress (not last)
+	      ctx.c = 0; // counter to zero
+	    }
+	    ctx.b[ctx.c++] = input[i];
+	  }
+	}
+
+	// Completes a BLAKE2b streaming hash
+	// Returns a Uint8Array containing the message digest
+	function blake2bFinal (ctx) {
+	  ctx.t += ctx.c; // mark last block offset
+
+	  while (ctx.c < 128) {
+	    // fill up with zeros
+	    ctx.b[ctx.c++] = 0;
+	  }
+	  blake2bCompress(ctx, true); // final block flag = 1
+
+	  // little endian convert and store
+	  const out = new Uint8Array(ctx.outlen);
+	  for (let i = 0; i < ctx.outlen; i++) {
+	    out[i] = ctx.h[i >> 2] >> (8 * (i & 3));
+	  }
+	  return out
+	}
+
+	// Computes the BLAKE2B hash of a string or byte array, and returns a Uint8Array
+	//
+	// Returns a n-byte Uint8Array
+	//
+	// Parameters:
+	// - input - the input bytes, as a string, Buffer or Uint8Array
+	// - key - optional key Uint8Array, up to 64 bytes
+	// - outlen - optional output length in bytes, default 64
+	// - salt - optional salt bytes, string, Buffer or Uint8Array
+	// - personal - optional personal bytes, string, Buffer or Uint8Array
+	function blake2b (input, key, outlen, salt, personal) {
+	  // preprocess inputs
+	  outlen = outlen || 64;
+	  input = util.normalizeInput(input);
+	  if (salt) {
+	    salt = util.normalizeInput(salt);
+	  }
+	  if (personal) {
+	    personal = util.normalizeInput(personal);
+	  }
+
+	  // do the math
+	  const ctx = blake2bInit(outlen, key, salt, personal);
+	  blake2bUpdate(ctx, input);
+	  return blake2bFinal(ctx)
+	}
+
+	// Computes the BLAKE2B hash of a string or byte array
+	//
+	// Returns an n-byte hash in hex, all lowercase
+	//
+	// Parameters:
+	// - input - the input bytes, as a string, Buffer, or Uint8Array
+	// - key - optional key Uint8Array, up to 64 bytes
+	// - outlen - optional output length in bytes, default 64
+	// - salt - optional salt bytes, string, Buffer or Uint8Array
+	// - personal - optional personal bytes, string, Buffer or Uint8Array
+	function blake2bHex (input, key, outlen, salt, personal) {
+	  const output = blake2b(input, key, outlen, salt, personal);
+	  return util.toHex(output)
+	}
+
+	blake2b_1 = {
+	  blake2b: blake2b,
+	  blake2bHex: blake2bHex,
+	  blake2bInit: blake2bInit,
+	  blake2bUpdate: blake2bUpdate,
+	  blake2bFinal: blake2bFinal
+	};
+	return blake2b_1;
+}
+
+var blake2s_1;
+var hasRequiredBlake2s;
+
+function requireBlake2s () {
+	if (hasRequiredBlake2s) return blake2s_1;
+	hasRequiredBlake2s = 1;
+	// BLAKE2s hash function in pure Javascript
+	// Adapted from the reference implementation in RFC7693
+	// Ported to Javascript by DC - https://github.com/dcposch
+
+	const util = requireUtil();
+
+	// Little-endian byte access.
+	// Expects a Uint8Array and an index
+	// Returns the little-endian uint32 at v[i..i+3]
+	function B2S_GET32 (v, i) {
+	  return v[i] ^ (v[i + 1] << 8) ^ (v[i + 2] << 16) ^ (v[i + 3] << 24)
+	}
+
+	// Mixing function G.
+	function B2S_G (a, b, c, d, x, y) {
+	  v[a] = v[a] + v[b] + x;
+	  v[d] = ROTR32(v[d] ^ v[a], 16);
+	  v[c] = v[c] + v[d];
+	  v[b] = ROTR32(v[b] ^ v[c], 12);
+	  v[a] = v[a] + v[b] + y;
+	  v[d] = ROTR32(v[d] ^ v[a], 8);
+	  v[c] = v[c] + v[d];
+	  v[b] = ROTR32(v[b] ^ v[c], 7);
+	}
+
+	// 32-bit right rotation
+	// x should be a uint32
+	// y must be between 1 and 31, inclusive
+	function ROTR32 (x, y) {
+	  return (x >>> y) ^ (x << (32 - y))
+	}
+
+	// Initialization Vector.
+	const BLAKE2S_IV = new Uint32Array([
+	  0x6a09e667,
+	  0xbb67ae85,
+	  0x3c6ef372,
+	  0xa54ff53a,
+	  0x510e527f,
+	  0x9b05688c,
+	  0x1f83d9ab,
+	  0x5be0cd19
+	]);
+
+	const SIGMA = new Uint8Array([
+	  0,
+	  1,
+	  2,
+	  3,
+	  4,
+	  5,
+	  6,
+	  7,
+	  8,
+	  9,
+	  10,
+	  11,
+	  12,
+	  13,
+	  14,
+	  15,
+	  14,
+	  10,
+	  4,
+	  8,
+	  9,
+	  15,
+	  13,
+	  6,
+	  1,
+	  12,
+	  0,
+	  2,
+	  11,
+	  7,
+	  5,
+	  3,
+	  11,
+	  8,
+	  12,
+	  0,
+	  5,
+	  2,
+	  15,
+	  13,
+	  10,
+	  14,
+	  3,
+	  6,
+	  7,
+	  1,
+	  9,
+	  4,
+	  7,
+	  9,
+	  3,
+	  1,
+	  13,
+	  12,
+	  11,
+	  14,
+	  2,
+	  6,
+	  5,
+	  10,
+	  4,
+	  0,
+	  15,
+	  8,
+	  9,
+	  0,
+	  5,
+	  7,
+	  2,
+	  4,
+	  10,
+	  15,
+	  14,
+	  1,
+	  11,
+	  12,
+	  6,
+	  8,
+	  3,
+	  13,
+	  2,
+	  12,
+	  6,
+	  10,
+	  0,
+	  11,
+	  8,
+	  3,
+	  4,
+	  13,
+	  7,
+	  5,
+	  15,
+	  14,
+	  1,
+	  9,
+	  12,
+	  5,
+	  1,
+	  15,
+	  14,
+	  13,
+	  4,
+	  10,
+	  0,
+	  7,
+	  6,
+	  3,
+	  9,
+	  2,
+	  8,
+	  11,
+	  13,
+	  11,
+	  7,
+	  14,
+	  12,
+	  1,
+	  3,
+	  9,
+	  5,
+	  0,
+	  15,
+	  4,
+	  8,
+	  6,
+	  2,
+	  10,
+	  6,
+	  15,
+	  14,
+	  9,
+	  11,
+	  3,
+	  0,
+	  8,
+	  12,
+	  2,
+	  13,
+	  7,
+	  1,
+	  4,
+	  10,
+	  5,
+	  10,
+	  2,
+	  8,
+	  4,
+	  7,
+	  6,
+	  1,
+	  5,
+	  15,
+	  11,
+	  9,
+	  14,
+	  3,
+	  12,
+	  13,
+	  0
+	]);
+
+	// Compression function. "last" flag indicates last block
+	const v = new Uint32Array(16);
+	const m = new Uint32Array(16);
+	function blake2sCompress (ctx, last) {
+	  let i = 0;
+	  for (i = 0; i < 8; i++) {
+	    // init work variables
+	    v[i] = ctx.h[i];
+	    v[i + 8] = BLAKE2S_IV[i];
+	  }
+
+	  v[12] ^= ctx.t; // low 32 bits of offset
+	  v[13] ^= ctx.t / 0x100000000; // high 32 bits
+	  if (last) {
+	    // last block flag set ?
+	    v[14] = ~v[14];
+	  }
+
+	  for (i = 0; i < 16; i++) {
+	    // get little-endian words
+	    m[i] = B2S_GET32(ctx.b, 4 * i);
+	  }
+
+	  // ten rounds of mixing
+	  // uncomment the DebugPrint calls to log the computation
+	  // and match the RFC sample documentation
+	  // util.debugPrint('          m[16]', m, 32)
+	  for (i = 0; i < 10; i++) {
+	    // util.debugPrint('   (i=' + i + ')  v[16]', v, 32)
+	    B2S_G(0, 4, 8, 12, m[SIGMA[i * 16 + 0]], m[SIGMA[i * 16 + 1]]);
+	    B2S_G(1, 5, 9, 13, m[SIGMA[i * 16 + 2]], m[SIGMA[i * 16 + 3]]);
+	    B2S_G(2, 6, 10, 14, m[SIGMA[i * 16 + 4]], m[SIGMA[i * 16 + 5]]);
+	    B2S_G(3, 7, 11, 15, m[SIGMA[i * 16 + 6]], m[SIGMA[i * 16 + 7]]);
+	    B2S_G(0, 5, 10, 15, m[SIGMA[i * 16 + 8]], m[SIGMA[i * 16 + 9]]);
+	    B2S_G(1, 6, 11, 12, m[SIGMA[i * 16 + 10]], m[SIGMA[i * 16 + 11]]);
+	    B2S_G(2, 7, 8, 13, m[SIGMA[i * 16 + 12]], m[SIGMA[i * 16 + 13]]);
+	    B2S_G(3, 4, 9, 14, m[SIGMA[i * 16 + 14]], m[SIGMA[i * 16 + 15]]);
+	  }
+	  // util.debugPrint('   (i=10) v[16]', v, 32)
+
+	  for (i = 0; i < 8; i++) {
+	    ctx.h[i] ^= v[i] ^ v[i + 8];
+	  }
+	  // util.debugPrint('h[8]', ctx.h, 32)
+	}
+
+	// Creates a BLAKE2s hashing context
+	// Requires an output length between 1 and 32 bytes
+	// Takes an optional Uint8Array key
+	function blake2sInit (outlen, key) {
+	  if (!(outlen > 0 && outlen <= 32)) {
+	    throw new Error('Incorrect output length, should be in [1, 32]')
+	  }
+	  const keylen = key ? key.length : 0;
+	  if (key && !(keylen > 0 && keylen <= 32)) {
+	    throw new Error('Incorrect key length, should be in [1, 32]')
+	  }
+
+	  const ctx = {
+	    h: new Uint32Array(BLAKE2S_IV), // hash state
+	    b: new Uint8Array(64), // input block
+	    c: 0, // pointer within block
+	    t: 0, // input count
+	    outlen: outlen // output length in bytes
+	  };
+	  ctx.h[0] ^= 0x01010000 ^ (keylen << 8) ^ outlen;
+
+	  if (keylen > 0) {
+	    blake2sUpdate(ctx, key);
+	    ctx.c = 64; // at the end
+	  }
+
+	  return ctx
+	}
+
+	// Updates a BLAKE2s streaming hash
+	// Requires hash context and Uint8Array (byte array)
+	function blake2sUpdate (ctx, input) {
+	  for (let i = 0; i < input.length; i++) {
+	    if (ctx.c === 64) {
+	      // buffer full ?
+	      ctx.t += ctx.c; // add counters
+	      blake2sCompress(ctx, false); // compress (not last)
+	      ctx.c = 0; // counter to zero
+	    }
+	    ctx.b[ctx.c++] = input[i];
+	  }
+	}
+
+	// Completes a BLAKE2s streaming hash
+	// Returns a Uint8Array containing the message digest
+	function blake2sFinal (ctx) {
+	  ctx.t += ctx.c; // mark last block offset
+	  while (ctx.c < 64) {
+	    // fill up with zeros
+	    ctx.b[ctx.c++] = 0;
+	  }
+	  blake2sCompress(ctx, true); // final block flag = 1
+
+	  // little endian convert and store
+	  const out = new Uint8Array(ctx.outlen);
+	  for (let i = 0; i < ctx.outlen; i++) {
+	    out[i] = (ctx.h[i >> 2] >> (8 * (i & 3))) & 0xff;
+	  }
+	  return out
+	}
+
+	// Computes the BLAKE2S hash of a string or byte array, and returns a Uint8Array
+	//
+	// Returns a n-byte Uint8Array
+	//
+	// Parameters:
+	// - input - the input bytes, as a string, Buffer, or Uint8Array
+	// - key - optional key Uint8Array, up to 32 bytes
+	// - outlen - optional output length in bytes, default 64
+	function blake2s (input, key, outlen) {
+	  // preprocess inputs
+	  outlen = outlen || 32;
+	  input = util.normalizeInput(input);
+
+	  // do the math
+	  const ctx = blake2sInit(outlen, key);
+	  blake2sUpdate(ctx, input);
+	  return blake2sFinal(ctx)
+	}
+
+	// Computes the BLAKE2S hash of a string or byte array
+	//
+	// Returns an n-byte hash in hex, all lowercase
+	//
+	// Parameters:
+	// - input - the input bytes, as a string, Buffer, or Uint8Array
+	// - key - optional key Uint8Array, up to 32 bytes
+	// - outlen - optional output length in bytes, default 64
+	function blake2sHex (input, key, outlen) {
+	  const output = blake2s(input, key, outlen);
+	  return util.toHex(output)
+	}
+
+	blake2s_1 = {
+	  blake2s: blake2s,
+	  blake2sHex: blake2sHex,
+	  blake2sInit: blake2sInit,
+	  blake2sUpdate: blake2sUpdate,
+	  blake2sFinal: blake2sFinal
+	};
+	return blake2s_1;
+}
+
+var blakejs;
+var hasRequiredBlakejs;
+
+function requireBlakejs () {
+	if (hasRequiredBlakejs) return blakejs;
+	hasRequiredBlakejs = 1;
+	const b2b = requireBlake2b();
+	const b2s = requireBlake2s();
+
+	blakejs = {
+	  blake2b: b2b.blake2b,
+	  blake2bHex: b2b.blake2bHex,
+	  blake2bInit: b2b.blake2bInit,
+	  blake2bUpdate: b2b.blake2bUpdate,
+	  blake2bFinal: b2b.blake2bFinal,
+	  blake2s: b2s.blake2s,
+	  blake2sHex: b2s.blake2sHex,
+	  blake2sInit: b2s.blake2sInit,
+	  blake2sUpdate: b2s.blake2sUpdate,
+	  blake2sFinal: b2s.blake2sFinal
+	};
+	return blakejs;
+}
 
 var hasRequiredHash;
 
@@ -118555,12 +118592,12 @@ function requireHash () {
 	hasRequiredHash = 1;
 	Object.defineProperty(hash, "__esModule", { value: true });
 	hash.ripemd160 = hash.blake128WithKey = hash.blake128 = hash.blake160WithKey = hash.blake160 = hash.blake256WithKey = hash.blake256 = void 0;
-	const crypto_js_1 = cryptoJsExports;
+	const crypto_js_1 = requireCryptoJs();
 	const utility_1 = requireUtility();
 	/**
 	 * @hidden
 	 */
-	const blake = blakejs;
+	const blake = requireBlakejs();
 	/**
 	 * Gets data's 256 bit blake hash.
 	 * @param data buffer or hexadecimal string