@xchainjs/xchain-thorchain 1.1.1 → 2.0.0

package/lib/index.esm.js

@@ -15,7 +15,7 @@ import { BigNumber } from 'bignumber.js';
 import { toWords as toWords$1, encode as encode$2 } from 'bech32';
 import { fromSeed } from 'bip32';
 import { publicKeyCreate } from 'secp256k1';
-import { assetToString, isSynthAsset, assetToBase, assetAmount, eqAsset, assetFromString, assetFromStringEx } from '@xchainjs/xchain-util';
+import { assetToString, isSynthAsset, AssetType, assetToBase, assetAmount, eqAsset, assetFromString, assetFromStringEx } from '@xchainjs/xchain-util';
 import { Network } from '@xchainjs/xchain-client';
 import THORChainApp, { extractSignatureFromTLV } from '@xchainjs/ledger-thorchain';
 
@@ -5511,13 +5511,13 @@ function requireMinimal () {
 
 var writer = Writer$1;
 
-var util$5      = requireMinimal();
+var util$7      = requireMinimal();
 
 var BufferWriter$1; // cyclic
 
-var LongBits$1  = util$5.LongBits,
-    base64    = util$5.base64,
-    utf8$1      = util$5.utf8;
+var LongBits$1  = util$7.LongBits,
+    base64    = util$7.base64,
+    utf8$1      = util$7.utf8;
 
 /**
  * Constructs a new writer operation instance.
@@ -5632,7 +5632,7 @@ function Writer$1() {
 }
 
 var create$1 = function create() {
-    return util$5.Buffer
+    return util$7.Buffer
         ? function create_buffer_setup() {
             return (Writer$1.create = function create_buffer() {
                 return new BufferWriter$1();
@@ -5657,13 +5657,13 @@ Writer$1.create = create$1();
  * @returns {Uint8Array} Buffer
  */
 Writer$1.alloc = function alloc(size) {
-    return new util$5.Array(size);
+    return new util$7.Array(size);
 };
 
 // Use Uint8Array buffer pool in the browser, just like node does with buffers
 /* istanbul ignore else */
-if (util$5.Array !== Array)
-    Writer$1.alloc = util$5.pool(Writer$1.alloc, util$5.Array.prototype.subarray);
+if (util$7.Array !== Array)
+    Writer$1.alloc = util$7.pool(Writer$1.alloc, util$7.Array.prototype.subarray);
 
 /**
  * Pushes a new operation to the queue.
@@ -5853,7 +5853,7 @@ Writer$1.prototype.sfixed64 = Writer$1.prototype.fixed64;
  * @returns {Writer} `this`
  */
 Writer$1.prototype.float = function write_float(value) {
-    return this._push(util$5.float.writeFloatLE, 4, value);
+    return this._push(util$7.float.writeFloatLE, 4, value);
 };
 
 /**
@@ -5863,10 +5863,10 @@ Writer$1.prototype.float = function write_float(value) {
  * @returns {Writer} `this`
  */
 Writer$1.prototype.double = function write_double(value) {
-    return this._push(util$5.float.writeDoubleLE, 8, value);
+    return this._push(util$7.float.writeDoubleLE, 8, value);
 };
 
-var writeBytes = util$5.Array.prototype.set
+var writeBytes = util$7.Array.prototype.set
     ? function writeBytes_set(val, buf, pos) {
         buf.set(val, pos); // also works for plain array values
     }
@@ -5885,7 +5885,7 @@ Writer$1.prototype.bytes = function write_bytes(value) {
     var len = value.length >>> 0;
     if (!len)
         return this._push(writeByte, 1, 0);
-    if (util$5.isString(value)) {
+    if (util$7.isString(value)) {
         var buf = Writer$1.alloc(len = base64.length(value));
         base64.decode(value, buf, 0);
         value = buf;
@@ -5980,7 +5980,7 @@ var writer_buffer = BufferWriter;
 var Writer = writer;
 (BufferWriter.prototype = Object.create(Writer.prototype)).constructor = BufferWriter;
 
-var util$4 = requireMinimal();
+var util$6 = requireMinimal();
 
 /**
  * Constructs a new buffer writer instance.
@@ -5999,9 +5999,9 @@ BufferWriter._configure = function () {
      * @param {number} size Buffer size
      * @returns {Buffer} Buffer
      */
-    BufferWriter.alloc = util$4._Buffer_allocUnsafe;
+    BufferWriter.alloc = util$6._Buffer_allocUnsafe;
 
-    BufferWriter.writeBytesBuffer = util$4.Buffer && util$4.Buffer.prototype instanceof Uint8Array && util$4.Buffer.prototype.set.name === "set"
+    BufferWriter.writeBytesBuffer = util$6.Buffer && util$6.Buffer.prototype instanceof Uint8Array && util$6.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
@@ -6020,8 +6020,8 @@ BufferWriter._configure = function () {
  * @override
  */
 BufferWriter.prototype.bytes = function write_bytes_buffer(value) {
-    if (util$4.isString(value))
-        value = util$4._Buffer_from(value, "base64");
+    if (util$6.isString(value))
+        value = util$6._Buffer_from(value, "base64");
     var len = value.length >>> 0;
     this.uint32(len);
     if (len)
@@ -6031,7 +6031,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$4.utf8.write(val, buf, pos);
+        util$6.utf8.write(val, buf, pos);
     else if (buf.utf8Write)
         buf.utf8Write(val, pos);
     else
@@ -6042,7 +6042,7 @@ function writeStringBuffer(val, buf, pos) {
  * @override
  */
 BufferWriter.prototype.string = function write_string_buffer(value) {
-    var len = util$4.Buffer.byteLength(value);
+    var len = util$6.Buffer.byteLength(value);
     this.uint32(len);
     if (len)
         this._push(writeStringBuffer, len, value);
@@ -6061,12 +6061,12 @@ BufferWriter._configure();
 
 var reader = Reader$1;
 
-var util$3      = requireMinimal();
+var util$5      = requireMinimal();
 
 var BufferReader$1; // cyclic
 
-var LongBits  = util$3.LongBits,
-    utf8      = util$3.utf8;
+var LongBits  = util$5.LongBits,
+    utf8      = util$5.utf8;
 
 /* istanbul ignore next */
 function indexOutOfRange(reader, writeLength) {
@@ -6114,10 +6114,10 @@ var create_array = typeof Uint8Array !== "undefined"
     };
 
 var create = function create() {
-    return util$3.Buffer
+    return util$5.Buffer
         ? function create_buffer_setup(buffer) {
             return (Reader$1.create = function create_buffer(buffer) {
-                return util$3.Buffer.isBuffer(buffer)
+                return util$5.Buffer.isBuffer(buffer)
                     ? new BufferReader$1(buffer)
                     /* istanbul ignore next */
                     : create_array(buffer);
@@ -6136,7 +6136,7 @@ var create = function create() {
  */
 Reader$1.create = create();
 
-Reader$1.prototype._slice = util$3.Array.prototype.subarray || /* istanbul ignore next */ util$3.Array.prototype.slice;
+Reader$1.prototype._slice = util$5.Array.prototype.subarray || /* istanbul ignore next */ util$5.Array.prototype.slice;
 
 /**
  * Reads a varint as an unsigned 32 bit value.
@@ -6335,7 +6335,7 @@ Reader$1.prototype.float = function read_float() {
     if (this.pos + 4 > this.len)
         throw indexOutOfRange(this, 4);
 
-    var value = util$3.float.readFloatLE(this.buf, this.pos);
+    var value = util$5.float.readFloatLE(this.buf, this.pos);
     this.pos += 4;
     return value;
 };
@@ -6351,7 +6351,7 @@ Reader$1.prototype.double = function read_double() {
     if (this.pos + 8 > this.len)
         throw indexOutOfRange(this, 4);
 
-    var value = util$3.float.readDoubleLE(this.buf, this.pos);
+    var value = util$5.float.readDoubleLE(this.buf, this.pos);
     this.pos += 8;
     return value;
 };
@@ -6444,8 +6444,8 @@ Reader$1._configure = function(BufferReader_) {
     Reader$1.create = create();
     BufferReader$1._configure();
 
-    var fn = util$3.Long ? "toLong" : /* istanbul ignore next */ "toNumber";
-    util$3.merge(Reader$1.prototype, {
+    var fn = util$5.Long ? "toLong" : /* istanbul ignore next */ "toNumber";
+    util$5.merge(Reader$1.prototype, {
 
         int64: function read_int64() {
             return readLongVarint.call(this)[fn](false);
@@ -6476,7 +6476,7 @@ var reader_buffer = BufferReader;
 var Reader = reader;
 (BufferReader.prototype = Object.create(Reader.prototype)).constructor = BufferReader;
 
-var util$2 = requireMinimal();
+var util$4 = requireMinimal();
 
 /**
  * Constructs a new buffer reader instance.
@@ -6497,8 +6497,8 @@ function BufferReader(buffer) {
 
 BufferReader._configure = function () {
     /* istanbul ignore else */
-    if (util$2.Buffer)
-        BufferReader.prototype._slice = util$2.Buffer.prototype.slice;
+    if (util$4.Buffer)
+        BufferReader.prototype._slice = util$4.Buffer.prototype.slice;
 };
 
 
@@ -6525,10 +6525,10 @@ var rpc = {};
 
 var service$1 = Service;
 
-var util$1 = requireMinimal();
+var util$3 = requireMinimal();
 
 // Extends EventEmitter
-(Service.prototype = Object.create(util$1.EventEmitter.prototype)).constructor = Service;
+(Service.prototype = Object.create(util$3.EventEmitter.prototype)).constructor = Service;
 
 /**
  * A service method callback as used by {@link rpc.ServiceMethod|ServiceMethod}.
@@ -6568,7 +6568,7 @@ function Service(rpcImpl, requestDelimited, responseDelimited) {
     if (typeof rpcImpl !== "function")
         throw TypeError("rpcImpl must be a function");
 
-    util$1.EventEmitter.call(this);
+    util$3.EventEmitter.call(this);
 
     /**
      * RPC implementation. Becomes `null` once the service is ended.
@@ -6607,7 +6607,7 @@ Service.prototype.rpcCall = function rpcCall(method, requestCtor, responseCtor,
 
     var self = this;
     if (!callback)
-        return util$1.asPromise(rpcCall, self, method, requestCtor, responseCtor, request);
+        return util$3.asPromise(rpcCall, self, method, requestCtor, responseCtor, request);
 
     if (!self.rpcImpl) {
         setTimeout(function() { callback(Error("already ended")); }, 0);
@@ -115180,25 +115180,20 @@ function requireBlowfish () {
 
 cryptoJs.exports;
 
-var hasRequiredCryptoJs;
-
-function requireCryptoJs () {
-	if (hasRequiredCryptoJs) return cryptoJs.exports;
-	hasRequiredCryptoJs = 1;
-	(function (module, 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) {
+		{
+			// 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) {
 
-			return CryptoJS;
+		return CryptoJS;
 
-		})); 
-	} (cryptoJs, cryptoJs.exports));
-	return cryptoJs.exports;
-}
+	})); 
+} (cryptoJs, cryptoJs.exports));
+
+var cryptoJsExports = cryptoJs.exports;
 
 var utility = {};
 
@@ -117703,858 +117698,826 @@ function requireUtility () {
 	return utility;
 }
 
-var util;
-var hasRequiredUtil;
-
-function requireUtil () {
-	if (hasRequiredUtil) return util;
-	hasRequiredUtil = 1;
-	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'
-	    );
-	  }
-	}
-
-	util = {
-	  normalizeInput: normalizeInput,
-	  toHex: toHex,
-	  debugPrint: debugPrint,
-	  testSpeed: testSpeed
-	};
-	return util;
-}
-
-var blake2b_1;
-var hasRequiredBlake2b;
-
-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
-
-	const util = requireUtil();
-
-	// 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
-	  }
+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
+};
 
-	  return ctx
-	}
+// 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
+]);
 
-	// 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];
-	  }
-	}
+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
+];
 
-	// 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
+// 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
+  })
+);
 
-	  // 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
-	}
+// 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
+]);
 
-	// 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)
-	}
+// 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
+};
 
-	blake2s_1 = {
-	  blake2s: blake2s,
-	  blake2sHex: blake2sHex,
-	  blake2sInit: blake2sInit,
-	  blake2sUpdate: blake2sUpdate,
-	  blake2sFinal: blake2sFinal
-	};
-	return blake2s_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 = 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 blakejs;
-var hasRequiredBlakejs;
+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 requireBlakejs () {
-	if (hasRequiredBlakejs) return blakejs;
-	hasRequiredBlakejs = 1;
-	const b2b = requireBlake2b();
-	const b2s = requireBlake2s();
+// 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
+};
 
-	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;
-}
+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
+};
 
 var hasRequiredHash;
 
@@ -118563,12 +118526,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 = requireCryptoJs();
+	const crypto_js_1 = cryptoJsExports;
 	const utility_1 = requireUtility();
 	/**
 	 * @hidden
 	 */
-	const blake = requireBlakejs();
+	const blake = blakejs;
 	/**
 	 * Gets data's 256 bit blake hash.
 	 * @param data buffer or hexadecimal string
@@ -124893,6 +124856,7 @@ $root.common = (function() {
          * @property {string|null} [symbol] Asset symbol
          * @property {string|null} [ticker] Asset ticker
          * @property {boolean|null} [synth] Asset synth
+         * @property {boolean|null} [trade] Asset trade
          */
 
         /**
@@ -124942,6 +124906,14 @@ $root.common = (function() {
          */
         Asset.prototype.synth = false;
 
+        /**
+         * Asset trade.
+         * @member {boolean} trade
+         * @memberof common.Asset
+         * @instance
+         */
+        Asset.prototype.trade = false;
+
         /**
          * Creates a new Asset instance using the specified properties.
          * @function create
@@ -124974,6 +124946,8 @@ $root.common = (function() {
                 writer.uint32(/* id 3, wireType 2 =*/26).string(message.ticker);
             if (message.synth != null && Object.hasOwnProperty.call(message, "synth"))
                 writer.uint32(/* id 4, wireType 0 =*/32).bool(message.synth);
+            if (message.trade != null && Object.hasOwnProperty.call(message, "trade"))
+                writer.uint32(/* id 5, wireType 0 =*/40).bool(message.trade);
             return writer;
         };
 
@@ -125020,6 +124994,9 @@ $root.common = (function() {
                 case 4:
                     message.synth = reader.bool();
                     break;
+                case 5:
+                    message.trade = reader.bool();
+                    break;
                 default:
                     reader.skipType(tag & 7);
                     break;
@@ -125067,6 +125044,9 @@ $root.common = (function() {
             if (message.synth != null && message.hasOwnProperty("synth"))
                 if (typeof message.synth !== "boolean")
                     return "synth: boolean expected";
+            if (message.trade != null && message.hasOwnProperty("trade"))
+                if (typeof message.trade !== "boolean")
+                    return "trade: boolean expected";
             return null;
         };
 
@@ -125090,6 +125070,8 @@ $root.common = (function() {
                 message.ticker = String(object.ticker);
             if (object.synth != null)
                 message.synth = Boolean(object.synth);
+            if (object.trade != null)
+                message.trade = Boolean(object.trade);
             return message;
         };
 
@@ -125111,6 +125093,7 @@ $root.common = (function() {
                 object.symbol = "";
                 object.ticker = "";
                 object.synth = false;
+                object.trade = false;
             }
             if (message.chain != null && message.hasOwnProperty("chain"))
                 object.chain = message.chain;
@@ -125120,6 +125103,8 @@ $root.common = (function() {
                 object.ticker = message.ticker;
             if (message.synth != null && message.hasOwnProperty("synth"))
                 object.synth = message.synth;
+            if (message.trade != null && message.hasOwnProperty("trade"))
+                object.trade = message.trade;
             return object;
         };
 
@@ -126193,6 +126178,193 @@ $root.common = (function() {
         return Fee;
     })();
 
+    common.ProtoUint = (function() {
+
+        /**
+         * Properties of a ProtoUint.
+         * @memberof common
+         * @interface IProtoUint
+         * @property {string|null} [value] ProtoUint value
+         */
+
+        /**
+         * Constructs a new ProtoUint.
+         * @memberof common
+         * @classdesc Represents a ProtoUint.
+         * @implements IProtoUint
+         * @constructor
+         * @param {common.IProtoUint=} [properties] Properties to set
+         */
+        function ProtoUint(properties) {
+            if (properties)
+                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
+                    if (properties[keys[i]] != null)
+                        this[keys[i]] = properties[keys[i]];
+        }
+
+        /**
+         * ProtoUint value.
+         * @member {string} value
+         * @memberof common.ProtoUint
+         * @instance
+         */
+        ProtoUint.prototype.value = "";
+
+        /**
+         * Creates a new ProtoUint instance using the specified properties.
+         * @function create
+         * @memberof common.ProtoUint
+         * @static
+         * @param {common.IProtoUint=} [properties] Properties to set
+         * @returns {common.ProtoUint} ProtoUint instance
+         */
+        ProtoUint.create = function create(properties) {
+            return new ProtoUint(properties);
+        };
+
+        /**
+         * Encodes the specified ProtoUint message. Does not implicitly {@link common.ProtoUint.verify|verify} messages.
+         * @function encode
+         * @memberof common.ProtoUint
+         * @static
+         * @param {common.IProtoUint} message ProtoUint message or plain object to encode
+         * @param {$protobuf.Writer} [writer] Writer to encode to
+         * @returns {$protobuf.Writer} Writer
+         */
+        ProtoUint.encode = function encode(message, writer) {
+            if (!writer)
+                writer = $Writer.create();
+            if (message.value != null && Object.hasOwnProperty.call(message, "value"))
+                writer.uint32(/* id 1, wireType 2 =*/10).string(message.value);
+            return writer;
+        };
+
+        /**
+         * Encodes the specified ProtoUint message, length delimited. Does not implicitly {@link common.ProtoUint.verify|verify} messages.
+         * @function encodeDelimited
+         * @memberof common.ProtoUint
+         * @static
+         * @param {common.IProtoUint} message ProtoUint message or plain object to encode
+         * @param {$protobuf.Writer} [writer] Writer to encode to
+         * @returns {$protobuf.Writer} Writer
+         */
+        ProtoUint.encodeDelimited = function encodeDelimited(message, writer) {
+            return this.encode(message, writer).ldelim();
+        };
+
+        /**
+         * Decodes a ProtoUint message from the specified reader or buffer.
+         * @function decode
+         * @memberof common.ProtoUint
+         * @static
+         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+         * @param {number} [length] Message length if known beforehand
+         * @returns {common.ProtoUint} ProtoUint
+         * @throws {Error} If the payload is not a reader or valid buffer
+         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+         */
+        ProtoUint.decode = function decode(reader, length) {
+            if (!(reader instanceof $Reader))
+                reader = $Reader.create(reader);
+            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.common.ProtoUint();
+            while (reader.pos < end) {
+                var tag = reader.uint32();
+                switch (tag >>> 3) {
+                case 1:
+                    message.value = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+                }
+            }
+            return message;
+        };
+
+        /**
+         * Decodes a ProtoUint message from the specified reader or buffer, length delimited.
+         * @function decodeDelimited
+         * @memberof common.ProtoUint
+         * @static
+         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+         * @returns {common.ProtoUint} ProtoUint
+         * @throws {Error} If the payload is not a reader or valid buffer
+         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+         */
+        ProtoUint.decodeDelimited = function decodeDelimited(reader) {
+            if (!(reader instanceof $Reader))
+                reader = new $Reader(reader);
+            return this.decode(reader, reader.uint32());
+        };
+
+        /**
+         * Verifies a ProtoUint message.
+         * @function verify
+         * @memberof common.ProtoUint
+         * @static
+         * @param {Object.<string,*>} message Plain object to verify
+         * @returns {string|null} `null` if valid, otherwise the reason why it is not
+         */
+        ProtoUint.verify = function verify(message) {
+            if (typeof message !== "object" || message === null)
+                return "object expected";
+            if (message.value != null && message.hasOwnProperty("value"))
+                if (!$util.isString(message.value))
+                    return "value: string expected";
+            return null;
+        };
+
+        /**
+         * Creates a ProtoUint message from a plain object. Also converts values to their respective internal types.
+         * @function fromObject
+         * @memberof common.ProtoUint
+         * @static
+         * @param {Object.<string,*>} object Plain object
+         * @returns {common.ProtoUint} ProtoUint
+         */
+        ProtoUint.fromObject = function fromObject(object) {
+            if (object instanceof $root.common.ProtoUint)
+                return object;
+            var message = new $root.common.ProtoUint();
+            if (object.value != null)
+                message.value = String(object.value);
+            return message;
+        };
+
+        /**
+         * Creates a plain object from a ProtoUint message. Also converts values to other types if specified.
+         * @function toObject
+         * @memberof common.ProtoUint
+         * @static
+         * @param {common.ProtoUint} message ProtoUint
+         * @param {$protobuf.IConversionOptions} [options] Conversion options
+         * @returns {Object.<string,*>} Plain object
+         */
+        ProtoUint.toObject = function toObject(message, options) {
+            if (!options)
+                options = {};
+            var object = {};
+            if (options.defaults)
+                object.value = "";
+            if (message.value != null && message.hasOwnProperty("value"))
+                object.value = message.value;
+            return object;
+        };
+
+        /**
+         * Converts this ProtoUint to JSON.
+         * @function toJSON
+         * @memberof common.ProtoUint
+         * @instance
+         * @returns {Object.<string,*>} JSON object
+         */
+        ProtoUint.prototype.toJSON = function toJSON() {
+            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+        };
+
+        return ProtoUint;
+    })();
+
     return common;
 })();
 
@@ -127622,14 +127794,14 @@ const getExplorerTxUrl = (tx) => ({
 /**
  * Checks whether an asset is the native RUNE asset
  *
- * @param {Asset} asset
+ * @param {CompatibleAsset} asset
  * @returns {boolean} `true` or `false`
  */
 const isAssetRuneNative = (asset) => assetToString(asset) === assetToString(AssetRuneNative);
 /**
  * Get denomination from Asset
  *
- * @param {Asset} asset
+ * @param {CompatibleAsset} asset
  * @returns {string} The denomination of the given asset
  */
 const getDenom = (asset) => {
@@ -127720,6 +127892,18 @@ function sortedObject(obj) {
 function sortAndStringifyJson(obj) {
     return JSON.stringify(sortedObject(obj));
 }
+/**
+ * Parse XChainJS asset to Thornode asset
+ */
+const parseAssetToTHORNodeAsset = (asset) => {
+    return {
+        chain: asset.chain,
+        symbol: asset.symbol,
+        ticker: asset.ticker,
+        synth: asset.type === AssetType.SYNTH,
+        trade: asset.type === AssetType.TRADE,
+    };
+};
 
 /**
  * Import necessary modules and types for the Thorchain client configuration.
@@ -127759,7 +127943,12 @@ const THORChain = 'THOR';
 /**
  * Native asset representation for RUNE in Thorchain
  */
-const AssetRuneNative = { chain: THORChain, symbol: RUNE_TICKER, ticker: RUNE_TICKER, synth: false };
+const AssetRuneNative = {
+    chain: THORChain,
+    symbol: RUNE_TICKER,
+    ticker: RUNE_TICKER,
+    type: AssetType.NATIVE,
+};
 /**
  * Message type URL used to make send transactions
  */
@@ -127822,7 +128011,7 @@ class Client extends Client$1 {
     /**
      * Returns the number of the decimals of known assets
      *
-     * @param {Asset} asset - Asset of which return the number of decimals
+     * @param {CompatibleAsset} asset - Asset of which return the number of decimals
      * @returns {number} the number of decimals of the assets
      */
     getAssetDecimals(asset) {
@@ -127860,7 +128049,7 @@ class Client extends Client$1 {
      * Get Asset from denomination
      *
      * @param {string} denom The denomination for which to get the asset.
-     * @returns {Asset|null} The asset of the given denomination.
+     * @returns {CompatibleAsset|null} The asset of the given denomination.
      */
     assetFromDenom(denom) {
         if (denom === RUNE_DENOM)
@@ -127870,7 +128059,7 @@ class Client extends Client$1 {
     /**
      * Get denomination from Asset
      *
-     * @param {Asset} asset The asset for which to get the denomination.
+     * @param {CompatibleAsset} asset The asset for which to get the denomination.
      * @returns {string} The denomination of the given asset.
      */
     getDenom(asset) {
@@ -128041,7 +128230,7 @@ class ClientKeystore extends Client {
      *
      * @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
+     * @param {CompatibleAsset} 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
@@ -128167,7 +128356,7 @@ class ClientKeystore extends Client {
      * @param {BigNumber} gasLimit Gas limit for the transaction
      * @param {BaseAmount} amount Amount to deposit
      * @param {string} memo Deposit memo
-     * @param {Asset} asset Asset to deposit
+     * @param {CompatibleAsset} asset Asset to deposit
      * @returns {DeliverTxResponse} The transaction broadcasted
      */
     roundRobinSignAndBroadcastDeposit(sender, signer, gasLimit, amount, memo, asset) {
@@ -128187,7 +128376,7 @@ class ClientKeystore extends Client {
                                 coins: [
                                     {
                                         amount: amount.amount().toString(),
-                                        asset,
+                                        asset: parseAssetToTHORNodeAsset(asset),
                                     },
                                 ],
                             },
@@ -128416,7 +128605,7 @@ class ClientLedger extends Client {
                     signer: bech32ToBase64(params.signer),
                     memo: params.memo,
                     coins: params.coins.map((coin) => {
-                        return Object.assign(Object.assign({}, coin), { asset: assetFromStringEx(coin.asset) });
+                        return Object.assign(Object.assign({}, coin), { asset: parseAssetToTHORNodeAsset(assetFromStringEx(coin.asset)) });
                     }),
                 }),
             },
@@ -128424,5 +128613,5 @@ class ClientLedger extends Client {
     }
 }
 
-export { AssetRuneNative, ClientKeystore as Client, ClientKeystore, ClientLedger, DEFAULT_EXPLORER_URL, DEFAULT_FEE, DEFAULT_GAS_LIMIT_VALUE, DEPOSIT_GAS_LIMIT_VALUE, MSG_DEPOSIT_TYPE_URL, MSG_SEND_TYPE_URL, RUNE_DECIMAL, RUNE_DENOM, RUNE_TICKER, THORChain, defaultClientConfig, getChainId, getDefaultClientUrls, getDefaultExplorers, getDefaultRootDerivationPaths, getDenom, getExplorerAddressUrl, getExplorerTxUrl, getPrefix, isAssetRuneNative, parseDerivationPath, sortAndStringifyJson, sortedObject };
+export { AssetRuneNative, ClientKeystore as Client, ClientKeystore, ClientLedger, DEFAULT_EXPLORER_URL, DEFAULT_FEE, DEFAULT_GAS_LIMIT_VALUE, DEPOSIT_GAS_LIMIT_VALUE, MSG_DEPOSIT_TYPE_URL, MSG_SEND_TYPE_URL, RUNE_DECIMAL, RUNE_DENOM, RUNE_TICKER, THORChain, defaultClientConfig, getChainId, getDefaultClientUrls, getDefaultExplorers, getDefaultRootDerivationPaths, getDenom, getExplorerAddressUrl, getExplorerTxUrl, getPrefix, isAssetRuneNative, parseAssetToTHORNodeAsset, parseDerivationPath, sortAndStringifyJson, sortedObject };
 //# sourceMappingURL=index.esm.js.map