@xchainjs/xchain-thorchain 0.28.13 → 0.28.14

package/lib/index.esm.js

@@ -4564,89 +4564,81 @@ function requireBase64 () {
 	return base64$1;
 }
 
-var eventemitter;
-var hasRequiredEventemitter;
-
-function requireEventemitter () {
-	if (hasRequiredEventemitter) return eventemitter;
-	hasRequiredEventemitter = 1;
-	eventemitter = EventEmitter;
+var eventemitter = EventEmitter;
 
-	/**
-	 * Constructs a new event emitter instance.
-	 * @classdesc A minimal event emitter.
-	 * @memberof util
-	 * @constructor
-	 */
-	function EventEmitter() {
-
-	    /**
-	     * Registered listeners.
-	     * @type {Object.<string,*>}
-	     * @private
-	     */
-	    this._listeners = {};
-	}
+/**
+ * Constructs a new event emitter instance.
+ * @classdesc A minimal event emitter.
+ * @memberof util
+ * @constructor
+ */
+function EventEmitter() {
 
-	/**
-	 * Registers an event listener.
-	 * @param {string} evt Event name
-	 * @param {function} fn Listener
-	 * @param {*} [ctx] Listener context
-	 * @returns {util.EventEmitter} `this`
-	 */
-	EventEmitter.prototype.on = function on(evt, fn, ctx) {
-	    (this._listeners[evt] || (this._listeners[evt] = [])).push({
-	        fn  : fn,
-	        ctx : ctx || this
-	    });
-	    return this;
-	};
+    /**
+     * Registered listeners.
+     * @type {Object.<string,*>}
+     * @private
+     */
+    this._listeners = {};
+}
 
-	/**
-	 * Removes an event listener or any matching listeners if arguments are omitted.
-	 * @param {string} [evt] Event name. Removes all listeners if omitted.
-	 * @param {function} [fn] Listener to remove. Removes all listeners of `evt` if omitted.
-	 * @returns {util.EventEmitter} `this`
-	 */
-	EventEmitter.prototype.off = function off(evt, fn) {
-	    if (evt === undefined)
-	        this._listeners = {};
-	    else {
-	        if (fn === undefined)
-	            this._listeners[evt] = [];
-	        else {
-	            var listeners = this._listeners[evt];
-	            for (var i = 0; i < listeners.length;)
-	                if (listeners[i].fn === fn)
-	                    listeners.splice(i, 1);
-	                else
-	                    ++i;
-	        }
-	    }
-	    return this;
-	};
+/**
+ * Registers an event listener.
+ * @param {string} evt Event name
+ * @param {function} fn Listener
+ * @param {*} [ctx] Listener context
+ * @returns {util.EventEmitter} `this`
+ */
+EventEmitter.prototype.on = function on(evt, fn, ctx) {
+    (this._listeners[evt] || (this._listeners[evt] = [])).push({
+        fn  : fn,
+        ctx : ctx || this
+    });
+    return this;
+};
 
-	/**
-	 * Emits an event by calling its listeners with the specified arguments.
-	 * @param {string} evt Event name
-	 * @param {...*} args Arguments
-	 * @returns {util.EventEmitter} `this`
-	 */
-	EventEmitter.prototype.emit = function emit(evt) {
-	    var listeners = this._listeners[evt];
-	    if (listeners) {
-	        var args = [],
-	            i = 1;
-	        for (; i < arguments.length;)
-	            args.push(arguments[i++]);
-	        for (i = 0; i < listeners.length;)
-	            listeners[i].fn.apply(listeners[i++].ctx, args);
-	    }
-	    return this;
-	};
-	return eventemitter;
-}
+/**
+ * Removes an event listener or any matching listeners if arguments are omitted.
+ * @param {string} [evt] Event name. Removes all listeners if omitted.
+ * @param {function} [fn] Listener to remove. Removes all listeners of `evt` if omitted.
+ * @returns {util.EventEmitter} `this`
+ */
+EventEmitter.prototype.off = function off(evt, fn) {
+    if (evt === undefined)
+        this._listeners = {};
+    else {
+        if (fn === undefined)
+            this._listeners[evt] = [];
+        else {
+            var listeners = this._listeners[evt];
+            for (var i = 0; i < listeners.length;)
+                if (listeners[i].fn === fn)
+                    listeners.splice(i, 1);
+                else
+                    ++i;
+        }
+    }
+    return this;
+};
+
+/**
+ * Emits an event by calling its listeners with the specified arguments.
+ * @param {string} evt Event name
+ * @param {...*} args Arguments
+ * @returns {util.EventEmitter} `this`
+ */
+EventEmitter.prototype.emit = function emit(evt) {
+    var listeners = this._listeners[evt];
+    if (listeners) {
+        var args = [],
+            i = 1;
+        for (; i < arguments.length;)
+            args.push(arguments[i++]);
+        for (i = 0; i < listeners.length;)
+            listeners[i].fn.apply(listeners[i++].ctx, args);
+    }
+    return this;
+};
 
 var float;
 var hasRequiredFloat;
@@ -4991,201 +4983,178 @@ function requireFloat () {
 	return float;
 }
 
-var inquire_1;
-var hasRequiredInquire;
-
-function requireInquire () {
-	if (hasRequiredInquire) return inquire_1;
-	hasRequiredInquire = 1;
-	inquire_1 = inquire;
+var inquire_1 = inquire;
 
-	/**
-	 * Requires a module only if available.
-	 * @memberof util
-	 * @param {string} moduleName Module to require
-	 * @returns {?Object} Required module if available and not empty, otherwise `null`
-	 */
-	function inquire(moduleName) {
-	    try {
-	        var mod = eval("quire".replace(/^/,"re"))(moduleName); // eslint-disable-line no-eval
-	        if (mod && (mod.length || Object.keys(mod).length))
-	            return mod;
-	    } catch (e) {} // eslint-disable-line no-empty
-	    return null;
-	}
-	return inquire_1;
+/**
+ * Requires a module only if available.
+ * @memberof util
+ * @param {string} moduleName Module to require
+ * @returns {?Object} Required module if available and not empty, otherwise `null`
+ */
+function inquire(moduleName) {
+    try {
+        var mod = eval("quire".replace(/^/,"re"))(moduleName); // eslint-disable-line no-eval
+        if (mod && (mod.length || Object.keys(mod).length))
+            return mod;
+    } catch (e) {} // eslint-disable-line no-empty
+    return null;
 }
 
 var utf8$2 = {};
 
-var hasRequiredUtf8;
-
-function requireUtf8 () {
-	if (hasRequiredUtf8) return utf8$2;
-	hasRequiredUtf8 = 1;
-	(function (exports) {
-
-		/**
-		 * A minimal UTF8 implementation for number arrays.
-		 * @memberof util
-		 * @namespace
-		 */
-		var utf8 = exports;
-
-		/**
-		 * Calculates the UTF8 byte length of a string.
-		 * @param {string} string String
-		 * @returns {number} Byte length
-		 */
-		utf8.length = function utf8_length(string) {
-		    var len = 0,
-		        c = 0;
-		    for (var i = 0; i < string.length; ++i) {
-		        c = string.charCodeAt(i);
-		        if (c < 128)
-		            len += 1;
-		        else if (c < 2048)
-		            len += 2;
-		        else if ((c & 0xFC00) === 0xD800 && (string.charCodeAt(i + 1) & 0xFC00) === 0xDC00) {
-		            ++i;
-		            len += 4;
-		        } else
-		            len += 3;
-		    }
-		    return len;
-		};
-
-		/**
-		 * Reads UTF8 bytes as a string.
-		 * @param {Uint8Array} buffer Source buffer
-		 * @param {number} start Source start
-		 * @param {number} end Source end
-		 * @returns {string} String read
-		 */
-		utf8.read = function utf8_read(buffer, start, end) {
-		    var len = end - start;
-		    if (len < 1)
-		        return "";
-		    var parts = null,
-		        chunk = [],
-		        i = 0, // char offset
-		        t;     // temporary
-		    while (start < end) {
-		        t = buffer[start++];
-		        if (t < 128)
-		            chunk[i++] = t;
-		        else if (t > 191 && t < 224)
-		            chunk[i++] = (t & 31) << 6 | buffer[start++] & 63;
-		        else if (t > 239 && t < 365) {
-		            t = ((t & 7) << 18 | (buffer[start++] & 63) << 12 | (buffer[start++] & 63) << 6 | buffer[start++] & 63) - 0x10000;
-		            chunk[i++] = 0xD800 + (t >> 10);
-		            chunk[i++] = 0xDC00 + (t & 1023);
-		        } else
-		            chunk[i++] = (t & 15) << 12 | (buffer[start++] & 63) << 6 | buffer[start++] & 63;
-		        if (i > 8191) {
-		            (parts || (parts = [])).push(String.fromCharCode.apply(String, chunk));
-		            i = 0;
-		        }
-		    }
-		    if (parts) {
-		        if (i)
-		            parts.push(String.fromCharCode.apply(String, chunk.slice(0, i)));
-		        return parts.join("");
-		    }
-		    return String.fromCharCode.apply(String, chunk.slice(0, i));
-		};
+(function (exports) {
 
-		/**
-		 * Writes a string as UTF8 bytes.
-		 * @param {string} string Source string
-		 * @param {Uint8Array} buffer Destination buffer
-		 * @param {number} offset Destination offset
-		 * @returns {number} Bytes written
-		 */
-		utf8.write = function utf8_write(string, buffer, offset) {
-		    var start = offset,
-		        c1, // character 1
-		        c2; // character 2
-		    for (var i = 0; i < string.length; ++i) {
-		        c1 = string.charCodeAt(i);
-		        if (c1 < 128) {
-		            buffer[offset++] = c1;
-		        } else if (c1 < 2048) {
-		            buffer[offset++] = c1 >> 6       | 192;
-		            buffer[offset++] = c1       & 63 | 128;
-		        } else if ((c1 & 0xFC00) === 0xD800 && ((c2 = string.charCodeAt(i + 1)) & 0xFC00) === 0xDC00) {
-		            c1 = 0x10000 + ((c1 & 0x03FF) << 10) + (c2 & 0x03FF);
-		            ++i;
-		            buffer[offset++] = c1 >> 18      | 240;
-		            buffer[offset++] = c1 >> 12 & 63 | 128;
-		            buffer[offset++] = c1 >> 6  & 63 | 128;
-		            buffer[offset++] = c1       & 63 | 128;
-		        } else {
-		            buffer[offset++] = c1 >> 12      | 224;
-		            buffer[offset++] = c1 >> 6  & 63 | 128;
-		            buffer[offset++] = c1       & 63 | 128;
-		        }
-		    }
-		    return offset - start;
-		}; 
-	} (utf8$2));
-	return utf8$2;
-}
-
-var pool_1;
-var hasRequiredPool;
-
-function requirePool () {
-	if (hasRequiredPool) return pool_1;
-	hasRequiredPool = 1;
-	pool_1 = pool;
+	/**
+	 * A minimal UTF8 implementation for number arrays.
+	 * @memberof util
+	 * @namespace
+	 */
+	var utf8 = exports;
 
 	/**
-	 * An allocator as used by {@link util.pool}.
-	 * @typedef PoolAllocator
-	 * @type {function}
-	 * @param {number} size Buffer size
-	 * @returns {Uint8Array} Buffer
+	 * Calculates the UTF8 byte length of a string.
+	 * @param {string} string String
+	 * @returns {number} Byte length
 	 */
+	utf8.length = function utf8_length(string) {
+	    var len = 0,
+	        c = 0;
+	    for (var i = 0; i < string.length; ++i) {
+	        c = string.charCodeAt(i);
+	        if (c < 128)
+	            len += 1;
+	        else if (c < 2048)
+	            len += 2;
+	        else if ((c & 0xFC00) === 0xD800 && (string.charCodeAt(i + 1) & 0xFC00) === 0xDC00) {
+	            ++i;
+	            len += 4;
+	        } else
+	            len += 3;
+	    }
+	    return len;
+	};
 
 	/**
-	 * A slicer as used by {@link util.pool}.
-	 * @typedef PoolSlicer
-	 * @type {function}
-	 * @param {number} start Start offset
-	 * @param {number} end End offset
-	 * @returns {Uint8Array} Buffer slice
-	 * @this {Uint8Array}
+	 * Reads UTF8 bytes as a string.
+	 * @param {Uint8Array} buffer Source buffer
+	 * @param {number} start Source start
+	 * @param {number} end Source end
+	 * @returns {string} String read
 	 */
+	utf8.read = function utf8_read(buffer, start, end) {
+	    var len = end - start;
+	    if (len < 1)
+	        return "";
+	    var parts = null,
+	        chunk = [],
+	        i = 0, // char offset
+	        t;     // temporary
+	    while (start < end) {
+	        t = buffer[start++];
+	        if (t < 128)
+	            chunk[i++] = t;
+	        else if (t > 191 && t < 224)
+	            chunk[i++] = (t & 31) << 6 | buffer[start++] & 63;
+	        else if (t > 239 && t < 365) {
+	            t = ((t & 7) << 18 | (buffer[start++] & 63) << 12 | (buffer[start++] & 63) << 6 | buffer[start++] & 63) - 0x10000;
+	            chunk[i++] = 0xD800 + (t >> 10);
+	            chunk[i++] = 0xDC00 + (t & 1023);
+	        } else
+	            chunk[i++] = (t & 15) << 12 | (buffer[start++] & 63) << 6 | buffer[start++] & 63;
+	        if (i > 8191) {
+	            (parts || (parts = [])).push(String.fromCharCode.apply(String, chunk));
+	            i = 0;
+	        }
+	    }
+	    if (parts) {
+	        if (i)
+	            parts.push(String.fromCharCode.apply(String, chunk.slice(0, i)));
+	        return parts.join("");
+	    }
+	    return String.fromCharCode.apply(String, chunk.slice(0, i));
+	};
 
 	/**
-	 * A general purpose buffer pool.
-	 * @memberof util
-	 * @function
-	 * @param {PoolAllocator} alloc Allocator
-	 * @param {PoolSlicer} slice Slicer
-	 * @param {number} [size=8192] Slab size
-	 * @returns {PoolAllocator} Pooled allocator
+	 * Writes a string as UTF8 bytes.
+	 * @param {string} string Source string
+	 * @param {Uint8Array} buffer Destination buffer
+	 * @param {number} offset Destination offset
+	 * @returns {number} Bytes written
 	 */
-	function pool(alloc, slice, size) {
-	    var SIZE   = size || 8192;
-	    var MAX    = SIZE >>> 1;
-	    var slab   = null;
-	    var offset = SIZE;
-	    return function pool_alloc(size) {
-	        if (size < 1 || size > MAX)
-	            return alloc(size);
-	        if (offset + size > SIZE) {
-	            slab = alloc(SIZE);
-	            offset = 0;
+	utf8.write = function utf8_write(string, buffer, offset) {
+	    var start = offset,
+	        c1, // character 1
+	        c2; // character 2
+	    for (var i = 0; i < string.length; ++i) {
+	        c1 = string.charCodeAt(i);
+	        if (c1 < 128) {
+	            buffer[offset++] = c1;
+	        } else if (c1 < 2048) {
+	            buffer[offset++] = c1 >> 6       | 192;
+	            buffer[offset++] = c1       & 63 | 128;
+	        } else if ((c1 & 0xFC00) === 0xD800 && ((c2 = string.charCodeAt(i + 1)) & 0xFC00) === 0xDC00) {
+	            c1 = 0x10000 + ((c1 & 0x03FF) << 10) + (c2 & 0x03FF);
+	            ++i;
+	            buffer[offset++] = c1 >> 18      | 240;
+	            buffer[offset++] = c1 >> 12 & 63 | 128;
+	            buffer[offset++] = c1 >> 6  & 63 | 128;
+	            buffer[offset++] = c1       & 63 | 128;
+	        } else {
+	            buffer[offset++] = c1 >> 12      | 224;
+	            buffer[offset++] = c1 >> 6  & 63 | 128;
+	            buffer[offset++] = c1       & 63 | 128;
 	        }
-	        var buf = slice.call(slab, offset, offset += size);
-	        if (offset & 7) // align to 32 bit
-	            offset = (offset | 7) + 1;
-	        return buf;
-	    };
-	}
-	return pool_1;
+	    }
+	    return offset - start;
+	}; 
+} (utf8$2));
+
+var pool_1 = pool;
+
+/**
+ * An allocator as used by {@link util.pool}.
+ * @typedef PoolAllocator
+ * @type {function}
+ * @param {number} size Buffer size
+ * @returns {Uint8Array} Buffer
+ */
+
+/**
+ * A slicer as used by {@link util.pool}.
+ * @typedef PoolSlicer
+ * @type {function}
+ * @param {number} start Start offset
+ * @param {number} end End offset
+ * @returns {Uint8Array} Buffer slice
+ * @this {Uint8Array}
+ */
+
+/**
+ * A general purpose buffer pool.
+ * @memberof util
+ * @function
+ * @param {PoolAllocator} alloc Allocator
+ * @param {PoolSlicer} slice Slicer
+ * @param {number} [size=8192] Slab size
+ * @returns {PoolAllocator} Pooled allocator
+ */
+function pool(alloc, slice, size) {
+    var SIZE   = size || 8192;
+    var MAX    = SIZE >>> 1;
+    var slab   = null;
+    var offset = SIZE;
+    return function pool_alloc(size) {
+        if (size < 1 || size > MAX)
+            return alloc(size);
+        if (offset + size > SIZE) {
+            slab = alloc(SIZE);
+            offset = 0;
+        }
+        var buf = slice.call(slab, offset, offset += size);
+        if (offset & 7) // align to 32 bit
+            offset = (offset | 7) + 1;
+        return buf;
+    };
 }
 
 var longbits;
@@ -5411,19 +5380,19 @@ function requireMinimal () {
 		util.base64 = requireBase64();
 
 		// base class of rpc.Service
-		util.EventEmitter = requireEventemitter();
+		util.EventEmitter = eventemitter;
 
 		// float handling accross browsers
 		util.float = requireFloat();
 
 		// requires modules optionally and hides the call from bundlers
-		util.inquire = requireInquire();
+		util.inquire = inquire_1;
 
 		// converts to / from utf8 encoded strings
-		util.utf8 = requireUtf8();
+		util.utf8 = utf8$2;
 
 		// provides a node-like buffer pool in the browser
-		util.pool = requirePool();
+		util.pool = pool_1;
 
 		// utility to work with the low and high bits of a 64 bit value
 		util.LongBits = requireLongbits();
@@ -10810,7 +10779,7 @@ class Client extends BaseXChainClient {
     getFees() {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                const { data: { int_64_values: { NativeTransactionFee: fee }, }, } = yield axios.get(`${this.getClientUrl().node}/thorchain/constants`);
+                const { data: { native_tx_fee_rune: fee }, } = yield axios.get(`${this.getClientUrl().node}/thorchain/network`);
                 // validate data
                 if (!fee || isNaN(fee) || fee < 0)
                     throw Error(`Invalid fee: ${fee.toString()}`);