@xchainjs/xchain-thorchain 1.0.11 → 1.1.1

package/lib/index.js

@@ -12,10 +12,11 @@ var crypto$3 = require('crypto');
 var buffer = require('buffer');
 var bignumber = require('bignumber.js');
 var bech32$1 = require('bech32');
-var xchainUtil = require('@xchainjs/xchain-util');
 var bip32 = require('bip32');
 var secp256k1 = require('secp256k1');
+var xchainUtil = require('@xchainjs/xchain-util');
 var xchainClient = require('@xchainjs/xchain-client');
+var THORChainApp = require('@xchainjs/ledger-thorchain');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -45,6 +46,7 @@ var axios__namespace = /*#__PURE__*/_interopNamespace(axios);
 var axios__default = /*#__PURE__*/_interopDefaultLegacy(axios);
 var buffer__namespace = /*#__PURE__*/_interopNamespace(buffer);
 var bignumber__namespace = /*#__PURE__*/_interopNamespace(bignumber);
+var THORChainApp__default = /*#__PURE__*/_interopDefaultLegacy(THORChainApp);
 
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
@@ -5538,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.
@@ -5659,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();
@@ -5684,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.
@@ -5880,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);
 };
 
 /**
@@ -5890,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
     }
@@ -5912,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;
@@ -6007,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.
@@ -6026,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
@@ -6047,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)
@@ -6058,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
@@ -6069,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);
@@ -6088,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) {
@@ -6141,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);
@@ -6163,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.
@@ -6362,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;
 };
@@ -6378,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;
 };
@@ -6471,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);
@@ -6503,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.
@@ -6524,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;
 };
 
 
@@ -6552,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}.
@@ -6595,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.
@@ -6634,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);
@@ -115207,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 = {};
 
@@ -117725,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;
 
@@ -118553,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
@@ -127658,6 +127697,58 @@ const getPrefix = (network) => {
             return 'tthor';
     }
 };
+/**
+ * Parse the derivation path from a string to an Array of numbers
+ * @param {string} path - Path to parse
+ * @returns {number[]} - The derivation path as Array of numbers
+ */
+const parseDerivationPath = (path) => {
+    if (!path.startsWith('m'))
+        throw new Error("Path string must start with 'm'");
+    let rest = path.slice(1);
+    const out = new Array();
+    while (rest) {
+        const match = rest.match(/^\/([0-9]+)('?)/);
+        if (!match)
+            throw new Error('Syntax error while reading path component');
+        const [fullMatch, numberString] = match;
+        const value = build$6.Uint53.fromString(numberString).toNumber();
+        if (value >= Math.pow(2, 31))
+            throw new Error('Component value too high. Must not exceed 2**31-1.');
+        out.push(value);
+        rest = rest.slice(fullMatch.length);
+    }
+    return out;
+};
+/**
+ * Sort JSON object
+ * @param {any} obj - JSON object
+ * @returns {any} JSON object sorted
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function sortedObject(obj) {
+    if (typeof obj !== 'object' || obj === null) {
+        return obj;
+    }
+    if (Array.isArray(obj)) {
+        return obj.map(sortedObject);
+    }
+    const sortedKeys = Object.keys(obj).sort();
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const result = {};
+    // NOTE: Use forEach instead of reduce for performance with large objects eg Wasm code
+    sortedKeys.forEach((key) => {
+        result[key] = sortedObject(obj[key]);
+    });
+    return result;
+}
+/**
+ * Returns a JSON string with objects sorted by key
+ * */
+// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
+function sortAndStringifyJson(obj) {
+    return JSON.stringify(sortedObject(obj));
+}
 
 /**
  * Import necessary modules and types for the Thorchain client configuration.
@@ -127727,7 +127818,7 @@ const defaultClientConfig = {
 };
 
 /**
- * Thorchain client
+ * Thorchain base client
  */
 class Client extends xchainCosmosSdk.Client {
     /**
@@ -127738,53 +127829,6 @@ class Client extends xchainCosmosSdk.Client {
     constructor(config = defaultClientConfig) {
         super(Object.assign(Object.assign({}, defaultClientConfig), config));
     }
-    /**
-     * Asynchronous version of getAddress method.
-     * @param {number} index Derivation path index of the address to be generated.
-     * @returns {string} A promise that resolves to the generated address.
-     */
-    getAddressAsync(index = 0) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.getAddress(index);
-        });
-    }
-    /**
-     * Get the address derived from the provided phrase.
-     * @param {number | undefined} walletIndex The index of the address derivation path. Default is 0.
-     * @returns {string} The user address at the specified walletIndex.
-     */
-    getAddress(walletIndex) {
-        const seed = getSeed(this.phrase);
-        const node = bip32.fromSeed(seed);
-        const child = node.derivePath(this.getFullDerivationPath(walletIndex || 0));
-        if (!child.privateKey)
-            throw new Error('child does not have a privateKey');
-        // TODO: Make this method async and use CosmosJS official address generation strategy
-        const pubKey = secp256k1.publicKeyCreate(child.privateKey);
-        const rawAddress = this.hash160(Uint8Array.from(pubKey));
-        const words = bech32$1.toWords(Buffer.from(rawAddress));
-        const address = bech32$1.encode(this.prefix, words);
-        return address;
-    }
-    transfer(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const sender = yield this.getAddressAsync(params.walletIndex || 0);
-            const { rawUnsignedTx } = yield this.prepareTx({
-                sender,
-                recipient: params.recipient,
-                asset: params.asset,
-                amount: params.amount,
-                memo: params.memo,
-            });
-            const unsignedTx = protoSigning.decodeTxRaw(encoding.fromBase64(rawUnsignedTx));
-            const signer = yield protoSigning.DirectSecp256k1HdWallet.fromMnemonic(this.phrase, {
-                prefix: this.prefix,
-                hdPaths: [xchainCosmosSdk.makeClientPath(this.getFullDerivationPath(params.walletIndex || 0))],
-            });
-            const tx = yield this.roundRobinSignAndBroadcastTx(sender, unsignedTx, signer);
-            return tx.transactionHash;
-        });
-    }
     /**
      * Get address prefix by network
      * @param {Network} network The network of which return the prefix
@@ -127905,60 +127949,70 @@ class Client extends xchainCosmosSdk.Client {
         });
     }
     /**
-     * Make a deposit
+     * Get deposit transaction
      *
-     * @param {number} param.walletIndex Optional - The index to use to generate the address from the transaction will be done.
-     * If it is not set, address associated with index 0 will be used
-     * @param {Asset} param.asset Optional - The asset that will be deposit. If it is not set, Thorchain native asset will be
-     * used
-     * @param {BaseAmount} param.amount The amount that will be deposit
-     * @param {string} param.memo Optional - The memo associated with the deposit
-     * @param {BigNumber} param.gasLimit Optional - The limit amount of gas allowed to spend in the deposit. If not set, default
-     * value of 600000000 will be used
-     * @returns {string} The deposit hash
+     * @deprecated Use getTransactionData instead
+     * @param {string} txId The transaction ID for which to get the deposit transaction
      */
-    deposit({ walletIndex = 0, asset = AssetRuneNative, amount, memo, gasLimit = new bignumber.BigNumber(DEPOSIT_GAS_LIMIT_VALUE), }) {
+    getDepositTransaction(txId) {
         return __awaiter(this, void 0, void 0, function* () {
-            // Get sender address
-            const sender = yield this.getAddressAsync(walletIndex);
-            // Create signer
-            const signer = yield protoSigning.DirectSecp256k1HdWallet.fromMnemonic(this.phrase, {
-                prefix: this.prefix,
-                hdPaths: [xchainCosmosSdk.makeClientPath(this.getFullDerivationPath(walletIndex || 0))],
-            });
-            const tx = yield this.roundRobinSignAndBroadcastDeposit(sender, signer, gasLimit, amount, memo, asset);
-            return tx.transactionHash;
+            return this.getTransactionData(txId);
         });
     }
     /**
-     * Create and sign transaction without broadcasting it
+     * Get the message type url by type used by the cosmos-sdk client to make certain actions
      *
-     * @deprecated Use prepare Tx instead
+     * @param {MsgTypes} msgType The message type of which return the type url
+     * @returns {string} the type url of the message
      */
-    transferOffline({ walletIndex = 0, recipient, asset, amount, memo, gasLimit = new bignumber.BigNumber(DEFAULT_GAS_LIMIT_VALUE), }) {
+    getMsgTypeUrlByType(msgType) {
+        const messageTypeUrls = {
+            [xchainCosmosSdk.MsgTypes.TRANSFER]: MSG_SEND_TYPE_URL,
+        };
+        return messageTypeUrls[msgType];
+    }
+    /**
+     * Returns the standard fee used by the client
+     *
+     * @returns {StdFee} the standard fee
+     */
+    getStandardFee() {
+        return { amount: [], gas: '6000000' };
+    }
+}
+
+/**
+ * Thorchain Keystore client
+ */
+class ClientKeystore extends Client {
+    /**
+     * Asynchronous version of getAddress method.
+     * @param {number} index Derivation path index of the address to be generated.
+     * @returns {string} A promise that resolves to the generated address.
+     */
+    getAddressAsync(index = 0) {
         return __awaiter(this, void 0, void 0, function* () {
-            // Get sender address
-            const sender = yield this.getAddressAsync(walletIndex);
-            // Prepare unsigned transaction
-            const { rawUnsignedTx } = yield this.prepareTx({
-                sender,
-                recipient: recipient,
-                asset: asset,
-                amount: amount,
-                memo: memo,
-            });
-            // Decode unsigned transaction
-            const unsignedTx = protoSigning.decodeTxRaw(encoding.fromBase64(rawUnsignedTx));
-            // Create signer
-            const signer = yield protoSigning.DirectSecp256k1HdWallet.fromMnemonic(this.phrase, {
-                prefix: this.prefix,
-                hdPaths: [xchainCosmosSdk.makeClientPath(this.getFullDerivationPath(walletIndex))],
-            });
-            const rawTx = yield this.roundRobinSign(sender, unsignedTx, signer, gasLimit);
-            // Return encoded signed transaction
-            return encoding.toBase64(tx$1.TxRaw.encode(rawTx).finish());
+            return this.getAddress(index);
         });
     }
+    /**
+     * Get the address derived from the provided phrase.
+     * @param {number | undefined} walletIndex The index of the address derivation path. Default is 0.
+     * @returns {string} The user address at the specified walletIndex.
+     */
+    getAddress(walletIndex) {
+        const seed = getSeed(this.phrase);
+        const node = bip32.fromSeed(seed);
+        const child = node.derivePath(this.getFullDerivationPath(walletIndex || 0));
+        if (!child.privateKey)
+            throw new Error('child does not have a privateKey');
+        // TODO: Make this method async and use CosmosJS official address generation strategy
+        const pubKey = secp256k1.publicKeyCreate(child.privateKey);
+        const rawAddress = this.hash160(Uint8Array.from(pubKey));
+        const words = bech32$1.toWords(Buffer.from(rawAddress));
+        const address = bech32$1.encode(this.prefix, words);
+        return address;
+    }
     /**
      * Returns the private key associated with an index
      *
@@ -127992,36 +128046,79 @@ class Client extends xchainCosmosSdk.Client {
             return crypto$2.Secp256k1.compressPubkey(pubkey);
         });
     }
-    /**
-     * Get deposit transaction
-     *
-     * @deprecated Use getTransactionData instead
-     * @param {string} txId The transaction ID for which to get the deposit transaction
-     */
-    getDepositTransaction(txId) {
+    transfer(params) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.getTransactionData(txId);
+            const sender = yield this.getAddressAsync(params.walletIndex || 0);
+            const { rawUnsignedTx } = yield this.prepareTx({
+                sender,
+                recipient: params.recipient,
+                asset: params.asset,
+                amount: params.amount,
+                memo: params.memo,
+            });
+            const unsignedTx = protoSigning.decodeTxRaw(encoding.fromBase64(rawUnsignedTx));
+            const signer = yield protoSigning.DirectSecp256k1HdWallet.fromMnemonic(this.phrase, {
+                prefix: this.prefix,
+                hdPaths: [xchainCosmosSdk.makeClientPath(this.getFullDerivationPath(params.walletIndex || 0))],
+            });
+            const tx = yield this.roundRobinSignAndBroadcastTx(sender, unsignedTx, signer);
+            return tx.transactionHash;
         });
     }
     /**
-     * Get the message type url by type used by the cosmos-sdk client to make certain actions
+     * Make a deposit
      *
-     * @param {MsgTypes} msgType The message type of which return the type url
-     * @returns {string} the type url of the message
+     * @param {number} param.walletIndex Optional - The index to use to generate the address from the transaction will be done.
+     * If it is not set, address associated with index 0 will be used
+     * @param {Asset} param.asset Optional - The asset that will be deposit. If it is not set, Thorchain native asset will be
+     * used
+     * @param {BaseAmount} param.amount The amount that will be deposit
+     * @param {string} param.memo Optional - The memo associated with the deposit
+     * @param {BigNumber} param.gasLimit Optional - The limit amount of gas allowed to spend in the deposit. If not set, default
+     * value of 600000000 will be used
+     * @returns {string} The deposit hash
      */
-    getMsgTypeUrlByType(msgType) {
-        const messageTypeUrls = {
-            [xchainCosmosSdk.MsgTypes.TRANSFER]: MSG_SEND_TYPE_URL,
-        };
-        return messageTypeUrls[msgType];
+    deposit({ walletIndex = 0, asset = AssetRuneNative, amount, memo, gasLimit = new bignumber.BigNumber(DEPOSIT_GAS_LIMIT_VALUE), }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Get sender address
+            const sender = yield this.getAddressAsync(walletIndex);
+            // Create signer
+            const signer = yield protoSigning.DirectSecp256k1HdWallet.fromMnemonic(this.phrase, {
+                prefix: this.prefix,
+                hdPaths: [xchainCosmosSdk.makeClientPath(this.getFullDerivationPath(walletIndex || 0))],
+            });
+            const tx = yield this.roundRobinSignAndBroadcastDeposit(sender, signer, gasLimit, amount, memo, asset);
+            return tx.transactionHash;
+        });
     }
     /**
-     * Returns the standard fee used by the client
+     * Create and sign transaction without broadcasting it
      *
-     * @returns {StdFee} the standard fee
+     * @deprecated Use prepare Tx instead
      */
-    getStandardFee() {
-        return { amount: [], gas: '6000000' };
+    transferOffline({ walletIndex = 0, recipient, asset, amount, memo, gasLimit = new bignumber.BigNumber(DEFAULT_GAS_LIMIT_VALUE), }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Get sender address
+            const sender = yield this.getAddressAsync(walletIndex);
+            // Prepare unsigned transaction
+            const { rawUnsignedTx } = yield this.prepareTx({
+                sender,
+                recipient: recipient,
+                asset: asset,
+                amount: amount,
+                memo: memo,
+            });
+            // Decode unsigned transaction
+            const unsignedTx = protoSigning.decodeTxRaw(encoding.fromBase64(rawUnsignedTx));
+            // Create signer
+            const signer = yield protoSigning.DirectSecp256k1HdWallet.fromMnemonic(this.phrase, {
+                prefix: this.prefix,
+                hdPaths: [xchainCosmosSdk.makeClientPath(this.getFullDerivationPath(walletIndex))],
+            });
+            const rawTx = yield this.roundRobinSign(sender, unsignedTx, signer, gasLimit);
+            // Return encoded signed transaction
+            return encoding.toBase64(tx$1.TxRaw.encode(rawTx).finish());
+        });
     }
     /**
      * Hashes a buffer using SHA256 followed by RIPEMD160 or RMD160.
@@ -128050,18 +128147,21 @@ class Client extends xchainCosmosSdk.Client {
         return __awaiter(this, void 0, void 0, function* () {
             // Connect to signing client
             for (const url of this.clientUrls[this.network]) {
-                const signingClient = yield build$7.SigningStargateClient.connectWithSigner(url, signer, {
-                    registry: this.registry,
-                });
-                // Prepare messages
-                const messages = unsignedTx.body.messages.map((message) => {
-                    return { typeUrl: this.getMsgTypeUrlByType(xchainCosmosSdk.MsgTypes.TRANSFER), value: signingClient.registry.decode(message) };
-                });
-                // Sign transaction
-                return yield signingClient.sign(sender, messages, {
-                    amount: [],
-                    gas: gasLimit.toString(),
-                }, unsignedTx.body.memo);
+                try {
+                    const signingClient = yield build$7.SigningStargateClient.connectWithSigner(url, signer, {
+                        registry: this.registry,
+                    });
+                    // Prepare messages
+                    const messages = unsignedTx.body.messages.map((message) => {
+                        return { typeUrl: this.getMsgTypeUrlByType(xchainCosmosSdk.MsgTypes.TRANSFER), value: signingClient.registry.decode(message) };
+                    });
+                    // Sign transaction
+                    return yield signingClient.sign(sender, messages, {
+                        amount: [],
+                        gas: gasLimit.toString(),
+                    }, unsignedTx.body.memo);
+                }
+                catch (_a) { }
             }
             throw Error('No clients available. Can not sign transaction');
         });
@@ -128133,8 +128233,230 @@ class Client extends xchainCosmosSdk.Client {
     }
 }
 
+/**
+ * Thorchain Ledger client
+ */
+class ClientLedger extends Client {
+    constructor(params) {
+        super(Object.assign(Object.assign({}, defaultClientConfig), params));
+        this.app = new THORChainApp__default["default"](params.transport);
+    }
+    /**
+     * Asynchronous version of getAddress method.
+     * @param {number} index Derivation path index of the address to be generated.
+     * @param {boolean} verify True to check the address against the Ledger device, otherwise false
+     * @returns {string} A promise that resolves to the generated address.
+     */
+    getAddressAsync(index, verify = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const derivationPath = parseDerivationPath(this.getFullDerivationPath(index || 0));
+            const { bech32Address } = verify
+                ? yield this.app.showAddressAndPubKey(derivationPath, this.getPrefix(this.network))
+                : yield this.app.getAddressAndPubKey(derivationPath, this.getPrefix(this.network));
+            return bech32Address;
+        });
+    }
+    /**
+     * @deprecated
+     * Asynchronous version of getAddress method. Not supported for ledger client
+     * @throws {Error} Not supported method
+     */
+    getAddress() {
+        throw Error('Sync method not supported for Ledger');
+    }
+    /**
+     * Transfers RUNE or synth token
+     *
+     * @param {TxParams} params The transfer options.
+     * @param {number} params.walletIndex Optional - The index to use to generate the address from the transaction will be done.
+     * If it is not set, address associated with index 0 will be used
+     * @param {asset} params.asset Optional - The asset that will be deposit. If it is not set, Thorchain native asset will be
+     * used
+     * @param {BaseAmount} params.amount The amount that will be transfer
+     * @param {string} params.recipient Recipient of the transfer
+     * @param {string} params.memo Optional - The memo associated with the transfer
+     * @returns {TxHash} The transaction hash.
+     */
+    transfer(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const signedTx = yield this.transferOffline(params);
+            return this.broadcastTx(signedTx);
+        });
+    }
+    /**
+     * Make a deposit
+     *
+     * @param {number} param.walletIndex Optional - The index to use to generate the address from the transaction will be done.
+     * If it is not set, address associated with index 0 will be used
+     * @param {Asset} param.asset Optional - The asset that will be deposit. If it is not set, Thorchain native asset will be
+     * used
+     * @param {BaseAmount} param.amount The amount that will be deposit
+     * @param {string} param.memo Optional - The memo associated with the deposit
+     * @param {BigNumber} param.gasLimit Optional - The limit amount of gas allowed to spend in the deposit. If not set, default
+     * value of 600000000 will be used
+     * @returns {string} The deposit hash
+     */
+    deposit({ walletIndex = 0, asset = AssetRuneNative, amount, memo, gasLimit = new bignumber.BigNumber(DEPOSIT_GAS_LIMIT_VALUE), }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const sender = yield this.getAddressAsync(walletIndex || 0);
+            const account = yield this.getAccount(sender);
+            const formattedDP = parseDerivationPath(this.getFullDerivationPath(walletIndex || 0));
+            const { compressedPk } = yield this.app.getAddressAndPubKey(formattedDP, this.getPrefix(this.getNetwork()));
+            const pubkey = protoSigning.encodePubkey({
+                type: 'tendermint/PubKeySecp256k1',
+                value: encoding.toBase64(compressedPk),
+            });
+            const msgs = sortedObject([
+                {
+                    type: 'thorchain/MsgDeposit',
+                    value: {
+                        signer: sender,
+                        memo,
+                        coins: [
+                            {
+                                amount: amount.amount().toString(),
+                                asset: xchainUtil.assetToString(asset),
+                            },
+                        ],
+                    },
+                },
+            ]);
+            const fee = { amount: [], gas: gasLimit.toString() };
+            const { signature, returnCode, errorMessage } = yield this.app.sign(formattedDP, sortAndStringifyJson({
+                account_number: account.accountNumber.toString(),
+                chain_id: yield this.getChainId(),
+                fee,
+                memo,
+                msgs,
+                sequence: account.sequence.toString(),
+            }));
+            if (!signature)
+                throw Error(`Can not sign deposit transaction. Return code ${returnCode}. Error: ${errorMessage}`);
+            const aminoTypes = this.getProtocolAminoMessages();
+            const rawTx = tx$1.TxRaw.fromPartial({
+                bodyBytes: yield this.registry.encodeTxBody({
+                    memo,
+                    messages: msgs.map((msg) => aminoTypes.fromAmino(msg)),
+                }),
+                authInfoBytes: protoSigning.makeAuthInfoBytes([
+                    {
+                        pubkey,
+                        sequence: account.sequence,
+                    },
+                ], fee.amount, Number.parseInt(fee.gas), undefined, undefined, signing.SignMode.SIGN_MODE_LEGACY_AMINO_JSON),
+                signatures: [THORChainApp.extractSignatureFromTLV(signature)],
+            });
+            return this.broadcastTx(encoding.toBase64(tx$1.TxRaw.encode(rawTx).finish()));
+        });
+    }
+    /**
+     * @deprecated
+     * Create a transaction and sign it without broadcasting it
+     *
+     * @param {TxParams} params The transfer options.
+     * @param {number} params.walletIndex Optional - The index to use to generate the address from the transaction will be done.
+     * If it is not set, address associated with index 0 will be used
+     * @param {asset} params.asset Optional - The asset that will be deposit. If it is not set, Thorchain native asset will be
+     * used
+     * @param {BaseAmount} params.amount The amount that will be transfer
+     * @param {string} params.recipient Recipient of the transfer
+     * @param {string} params.memo Optional - The memo associated with the transfer
+     * @returns {TxHash} The transaction hash.
+     */
+    transferOffline(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const sender = yield this.getAddressAsync(params.walletIndex || 0);
+            const account = yield this.getAccount(sender);
+            const formattedDP = parseDerivationPath(this.getFullDerivationPath(params.walletIndex || 0));
+            const { compressedPk } = yield this.app.getAddressAndPubKey(formattedDP, this.getPrefix(this.getNetwork()));
+            const pubkey = protoSigning.encodePubkey({
+                type: 'tendermint/PubKeySecp256k1',
+                value: encoding.toBase64(compressedPk),
+            });
+            const msgs = sortedObject([
+                {
+                    type: 'thorchain/MsgSend',
+                    value: {
+                        from_address: sender,
+                        to_address: params.recipient,
+                        amount: [
+                            {
+                                amount: params.amount.amount().toString(),
+                                denom: this.getDenom(params.asset || AssetRuneNative),
+                            },
+                        ],
+                    },
+                },
+            ]);
+            const fee = this.getStandardFee();
+            const { signature, returnCode, errorMessage } = yield this.app.sign(formattedDP, sortAndStringifyJson({
+                account_number: account.accountNumber.toString(),
+                chain_id: yield this.getChainId(),
+                fee,
+                memo: params.memo || '',
+                msgs,
+                sequence: account.sequence.toString(),
+            }));
+            if (!signature)
+                throw Error(`Can not sign transfer transaction. Return code ${returnCode}. Error: ${errorMessage}`);
+            const aminoTypes = this.getProtocolAminoMessages();
+            const rawTx = tx$1.TxRaw.fromPartial({
+                bodyBytes: yield this.registry.encodeTxBody({
+                    messages: msgs.map((msg) => aminoTypes.fromAmino(msg)),
+                    memo: params.memo,
+                }),
+                authInfoBytes: protoSigning.makeAuthInfoBytes([
+                    {
+                        pubkey,
+                        sequence: account.sequence,
+                    },
+                ], fee.amount, Number.parseInt(fee.gas), undefined, undefined, signing.SignMode.SIGN_MODE_LEGACY_AMINO_JSON),
+                signatures: [THORChainApp.extractSignatureFromTLV(signature)],
+            });
+            return encoding.toBase64(tx$1.TxRaw.encode(rawTx).finish());
+        });
+    }
+    getProtocolAminoMessages() {
+        const prefix = this.getPrefix(this.network);
+        return new build$7.AminoTypes({
+            '/types.MsgSend': {
+                aminoType: `thorchain/MsgSend`,
+                toAmino: (params) => ({
+                    from_address: xchainCosmosSdk.base64ToBech32(params.fromAddress, prefix),
+                    to_address: xchainCosmosSdk.base64ToBech32(params.toAddress, prefix),
+                    amount: [...params.amount],
+                }),
+                fromAmino: (params) => ({
+                    fromAddress: xchainCosmosSdk.bech32ToBase64(params.from_address),
+                    toAddress: xchainCosmosSdk.bech32ToBase64(params.to_address),
+                    amount: [...params.amount],
+                }),
+            },
+            '/types.MsgDeposit': {
+                aminoType: `thorchain/MsgDeposit`,
+                toAmino: (params) => ({
+                    signer: xchainCosmosSdk.base64ToBech32(params.signer, prefix),
+                    memo: params.memo,
+                    coins: params.coins.map((coin) => {
+                        return Object.assign(Object.assign({}, coin), { asset: xchainUtil.assetToString(coin.asset) });
+                    }),
+                }),
+                fromAmino: (params) => ({
+                    signer: xchainCosmosSdk.bech32ToBase64(params.signer),
+                    memo: params.memo,
+                    coins: params.coins.map((coin) => {
+                        return Object.assign(Object.assign({}, coin), { asset: xchainUtil.assetFromStringEx(coin.asset) });
+                    }),
+                }),
+            },
+        });
+    }
+}
+
 exports.AssetRuneNative = AssetRuneNative;
-exports.Client = Client;
+exports.Client = ClientKeystore;
+exports.ClientKeystore = ClientKeystore;
+exports.ClientLedger = ClientLedger;
 exports.DEFAULT_EXPLORER_URL = DEFAULT_EXPLORER_URL;
 exports.DEFAULT_FEE = DEFAULT_FEE;
 exports.DEFAULT_GAS_LIMIT_VALUE = DEFAULT_GAS_LIMIT_VALUE;
@@ -128155,4 +128477,7 @@ exports.getExplorerAddressUrl = getExplorerAddressUrl;
 exports.getExplorerTxUrl = getExplorerTxUrl;
 exports.getPrefix = getPrefix;
 exports.isAssetRuneNative = isAssetRuneNative;
+exports.parseDerivationPath = parseDerivationPath;
+exports.sortAndStringifyJson = sortAndStringifyJson;
+exports.sortedObject = sortedObject;
 //# sourceMappingURL=index.js.map