@xchainjs/xchain-thorchain 0.28.2 → 0.28.4

package/lib/index.js

@@ -4285,7 +4285,7 @@ const addressUrl = `${DEFAULT_EXPLORER_URL}/address`;
 const RUNE_TICKER = 'RUNE';
 const RUNE_DECIMAL = 8;
 const DEFAULT_GAS_ADJUSTMENT = 2;
-const DEFAULT_GAS_LIMIT_VALUE = '4000000';
+const DEFAULT_GAS_LIMIT_VALUE = '6000000';
 const DEPOSIT_GAS_LIMIT_VALUE = '600000000';
 const MAX_TX_COUNT_PER_PAGE = 100;
 const MAX_TX_COUNT_PER_FUNCTION_CALL = 500;
@@ -4382,215 +4382,200 @@ var indexMinimal = {};
 
 var minimal$1 = {};
 
-var aspromise;
-var hasRequiredAspromise;
+var aspromise = asPromise;
+
+/**
+ * Callback as used by {@link util.asPromise}.
+ * @typedef asPromiseCallback
+ * @type {function}
+ * @param {Error|null} error Error, if any
+ * @param {...*} params Additional arguments
+ * @returns {undefined}
+ */
+
+/**
+ * Returns a promise from a node-style callback function.
+ * @memberof util
+ * @param {asPromiseCallback} fn Function to call
+ * @param {*} ctx Function context
+ * @param {...*} params Function arguments
+ * @returns {Promise<*>} Promisified function
+ */
+function asPromise(fn, ctx/*, varargs */) {
+    var params  = new Array(arguments.length - 1),
+        offset  = 0,
+        index   = 2,
+        pending = true;
+    while (index < arguments.length)
+        params[offset++] = arguments[index++];
+    return new Promise(function executor(resolve, reject) {
+        params[offset] = function callback(err/*, varargs */) {
+            if (pending) {
+                pending = false;
+                if (err)
+                    reject(err);
+                else {
+                    var params = new Array(arguments.length - 1),
+                        offset = 0;
+                    while (offset < params.length)
+                        params[offset++] = arguments[offset];
+                    resolve.apply(null, params);
+                }
+            }
+        };
+        try {
+            fn.apply(ctx || null, params);
+        } catch (err) {
+            if (pending) {
+                pending = false;
+                reject(err);
+            }
+        }
+    });
+}
 
-function requireAspromise () {
-	if (hasRequiredAspromise) return aspromise;
-	hasRequiredAspromise = 1;
-	aspromise = asPromise;
+var base64$1 = {};
+
+(function (exports) {
 
 	/**
-	 * Callback as used by {@link util.asPromise}.
-	 * @typedef asPromiseCallback
-	 * @type {function}
-	 * @param {Error|null} error Error, if any
-	 * @param {...*} params Additional arguments
-	 * @returns {undefined}
+	 * A minimal base64 implementation for number arrays.
+	 * @memberof util
+	 * @namespace
 	 */
+	var base64 = exports;
 
 	/**
-	 * Returns a promise from a node-style callback function.
-	 * @memberof util
-	 * @param {asPromiseCallback} fn Function to call
-	 * @param {*} ctx Function context
-	 * @param {...*} params Function arguments
-	 * @returns {Promise<*>} Promisified function
+	 * Calculates the byte length of a base64 encoded string.
+	 * @param {string} string Base64 encoded string
+	 * @returns {number} Byte length
+	 */
+	base64.length = function length(string) {
+	    var p = string.length;
+	    if (!p)
+	        return 0;
+	    var n = 0;
+	    while (--p % 4 > 1 && string.charAt(p) === "=")
+	        ++n;
+	    return Math.ceil(string.length * 3) / 4 - n;
+	};
+
+	// Base64 encoding table
+	var b64 = new Array(64);
+
+	// Base64 decoding table
+	var s64 = new Array(123);
+
+	// 65..90, 97..122, 48..57, 43, 47
+	for (var i = 0; i < 64;)
+	    s64[b64[i] = i < 26 ? i + 65 : i < 52 ? i + 71 : i < 62 ? i - 4 : i - 59 | 43] = i++;
+
+	/**
+	 * Encodes a buffer to a base64 encoded string.
+	 * @param {Uint8Array} buffer Source buffer
+	 * @param {number} start Source start
+	 * @param {number} end Source end
+	 * @returns {string} Base64 encoded string
 	 */
-	function asPromise(fn, ctx/*, varargs */) {
-	    var params  = new Array(arguments.length - 1),
-	        offset  = 0,
-	        index   = 2,
-	        pending = true;
-	    while (index < arguments.length)
-	        params[offset++] = arguments[index++];
-	    return new Promise(function executor(resolve, reject) {
-	        params[offset] = function callback(err/*, varargs */) {
-	            if (pending) {
-	                pending = false;
-	                if (err)
-	                    reject(err);
-	                else {
-	                    var params = new Array(arguments.length - 1),
-	                        offset = 0;
-	                    while (offset < params.length)
-	                        params[offset++] = arguments[offset];
-	                    resolve.apply(null, params);
-	                }
-	            }
-	        };
-	        try {
-	            fn.apply(ctx || null, params);
-	        } catch (err) {
-	            if (pending) {
-	                pending = false;
-	                reject(err);
-	            }
+	base64.encode = function encode(buffer, start, end) {
+	    var parts = null,
+	        chunk = [];
+	    var i = 0, // output index
+	        j = 0, // goto index
+	        t;     // temporary
+	    while (start < end) {
+	        var b = buffer[start++];
+	        switch (j) {
+	            case 0:
+	                chunk[i++] = b64[b >> 2];
+	                t = (b & 3) << 4;
+	                j = 1;
+	                break;
+	            case 1:
+	                chunk[i++] = b64[t | b >> 4];
+	                t = (b & 15) << 2;
+	                j = 2;
+	                break;
+	            case 2:
+	                chunk[i++] = b64[t | b >> 6];
+	                chunk[i++] = b64[b & 63];
+	                j = 0;
+	                break;
 	        }
-	    });
-	}
-	return aspromise;
-}
-
-var base64$1 = {};
-
-var hasRequiredBase64;
-
-function requireBase64 () {
-	if (hasRequiredBase64) return base64$1;
-	hasRequiredBase64 = 1;
-	(function (exports) {
+	        if (i > 8191) {
+	            (parts || (parts = [])).push(String.fromCharCode.apply(String, chunk));
+	            i = 0;
+	        }
+	    }
+	    if (j) {
+	        chunk[i++] = b64[t];
+	        chunk[i++] = 61;
+	        if (j === 1)
+	            chunk[i++] = 61;
+	    }
+	    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));
+	};
+
+	var invalidEncoding = "invalid encoding";
 
-		/**
-		 * A minimal base64 implementation for number arrays.
-		 * @memberof util
-		 * @namespace
-		 */
-		var base64 = exports;
-
-		/**
-		 * Calculates the byte length of a base64 encoded string.
-		 * @param {string} string Base64 encoded string
-		 * @returns {number} Byte length
-		 */
-		base64.length = function length(string) {
-		    var p = string.length;
-		    if (!p)
-		        return 0;
-		    var n = 0;
-		    while (--p % 4 > 1 && string.charAt(p) === "=")
-		        ++n;
-		    return Math.ceil(string.length * 3) / 4 - n;
-		};
-
-		// Base64 encoding table
-		var b64 = new Array(64);
-
-		// Base64 decoding table
-		var s64 = new Array(123);
-
-		// 65..90, 97..122, 48..57, 43, 47
-		for (var i = 0; i < 64;)
-		    s64[b64[i] = i < 26 ? i + 65 : i < 52 ? i + 71 : i < 62 ? i - 4 : i - 59 | 43] = i++;
-
-		/**
-		 * Encodes a buffer to a base64 encoded string.
-		 * @param {Uint8Array} buffer Source buffer
-		 * @param {number} start Source start
-		 * @param {number} end Source end
-		 * @returns {string} Base64 encoded string
-		 */
-		base64.encode = function encode(buffer, start, end) {
-		    var parts = null,
-		        chunk = [];
-		    var i = 0, // output index
-		        j = 0, // goto index
-		        t;     // temporary
-		    while (start < end) {
-		        var b = buffer[start++];
-		        switch (j) {
-		            case 0:
-		                chunk[i++] = b64[b >> 2];
-		                t = (b & 3) << 4;
-		                j = 1;
-		                break;
-		            case 1:
-		                chunk[i++] = b64[t | b >> 4];
-		                t = (b & 15) << 2;
-		                j = 2;
-		                break;
-		            case 2:
-		                chunk[i++] = b64[t | b >> 6];
-		                chunk[i++] = b64[b & 63];
-		                j = 0;
-		                break;
-		        }
-		        if (i > 8191) {
-		            (parts || (parts = [])).push(String.fromCharCode.apply(String, chunk));
-		            i = 0;
-		        }
-		    }
-		    if (j) {
-		        chunk[i++] = b64[t];
-		        chunk[i++] = 61;
-		        if (j === 1)
-		            chunk[i++] = 61;
-		    }
-		    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));
-		};
-
-		var invalidEncoding = "invalid encoding";
-
-		/**
-		 * Decodes a base64 encoded string to a buffer.
-		 * @param {string} string Source string
-		 * @param {Uint8Array} buffer Destination buffer
-		 * @param {number} offset Destination offset
-		 * @returns {number} Number of bytes written
-		 * @throws {Error} If encoding is invalid
-		 */
-		base64.decode = function decode(string, buffer, offset) {
-		    var start = offset;
-		    var j = 0, // goto index
-		        t;     // temporary
-		    for (var i = 0; i < string.length;) {
-		        var c = string.charCodeAt(i++);
-		        if (c === 61 && j > 1)
-		            break;
-		        if ((c = s64[c]) === undefined)
-		            throw Error(invalidEncoding);
-		        switch (j) {
-		            case 0:
-		                t = c;
-		                j = 1;
-		                break;
-		            case 1:
-		                buffer[offset++] = t << 2 | (c & 48) >> 4;
-		                t = c;
-		                j = 2;
-		                break;
-		            case 2:
-		                buffer[offset++] = (t & 15) << 4 | (c & 60) >> 2;
-		                t = c;
-		                j = 3;
-		                break;
-		            case 3:
-		                buffer[offset++] = (t & 3) << 6 | c;
-		                j = 0;
-		                break;
-		        }
-		    }
-		    if (j === 1)
-		        throw Error(invalidEncoding);
-		    return offset - start;
-		};
-
-		/**
-		 * Tests if the specified string appears to be base64 encoded.
-		 * @param {string} string String to test
-		 * @returns {boolean} `true` if probably base64 encoded, otherwise false
-		 */
-		base64.test = function test(string) {
-		    return /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(string);
-		}; 
-	} (base64$1));
-	return base64$1;
-}
+	/**
+	 * Decodes a base64 encoded string to a buffer.
+	 * @param {string} string Source string
+	 * @param {Uint8Array} buffer Destination buffer
+	 * @param {number} offset Destination offset
+	 * @returns {number} Number of bytes written
+	 * @throws {Error} If encoding is invalid
+	 */
+	base64.decode = function decode(string, buffer, offset) {
+	    var start = offset;
+	    var j = 0, // goto index
+	        t;     // temporary
+	    for (var i = 0; i < string.length;) {
+	        var c = string.charCodeAt(i++);
+	        if (c === 61 && j > 1)
+	            break;
+	        if ((c = s64[c]) === undefined)
+	            throw Error(invalidEncoding);
+	        switch (j) {
+	            case 0:
+	                t = c;
+	                j = 1;
+	                break;
+	            case 1:
+	                buffer[offset++] = t << 2 | (c & 48) >> 4;
+	                t = c;
+	                j = 2;
+	                break;
+	            case 2:
+	                buffer[offset++] = (t & 15) << 4 | (c & 60) >> 2;
+	                t = c;
+	                j = 3;
+	                break;
+	            case 3:
+	                buffer[offset++] = (t & 3) << 6 | c;
+	                j = 0;
+	                break;
+	        }
+	    }
+	    if (j === 1)
+	        throw Error(invalidEncoding);
+	    return offset - start;
+	};
+
+	/**
+	 * Tests if the specified string appears to be base64 encoded.
+	 * @param {string} string String to test
+	 * @returns {boolean} `true` if probably base64 encoded, otherwise false
+	 */
+	base64.test = function test(string) {
+	    return /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(string);
+	}; 
+} (base64$1));
 
 var eventemitter = EventEmitter;
 
@@ -5002,201 +4987,178 @@ function readUintBE(buf, pos) {
           | buf[pos + 3]) >>> 0;
 }
 
-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) {
+(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));
-		};
-
-		/**
-		 * 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;
@@ -5416,10 +5378,10 @@ function requireMinimal () {
 		var util = exports;
 
 		// used to return a Promise where callback is omitted
-		util.asPromise = requireAspromise();
+		util.asPromise = aspromise;
 
 		// converts to / from base64 encoded strings
-		util.base64 = requireBase64();
+		util.base64 = base64$1;
 
 		// base class of rpc.Service
 		util.EventEmitter = eventemitter;
@@ -5428,13 +5390,13 @@ function requireMinimal () {
 		util.float = float;
 
 		// 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();
@@ -10219,7 +10181,10 @@ class Client extends xchainClient.BaseXChainClient {
             const txs = [];
             for (let i = 0; i < history.length; i += 10) {
                 const batch = history.slice(i, i + 10);
-                const result = yield Promise.all(batch.map(({ hash }) => this.getTransactionData(hash, address)));
+                const result = yield Promise.all(batch.map(({ hash }) => __awaiter(this, void 0, void 0, function* () {
+                    const data = yield this.getTransactionData(hash, address);
+                    return data;
+                })));
                 txs.push(...result);
                 xchainUtil.delay(2000); // Delay to avoid 503 from ninerealms server
             }
@@ -10452,65 +10417,91 @@ class Client extends xchainClient.BaseXChainClient {
      * @returns {Tx} The transaction details of the given transaction id.
      */
     getTransactionData(txId, address) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d, _e, _f;
         return __awaiter(this, void 0, void 0, function* () {
-            const response = yield this.fetchTransaction(txId);
-            if (response) {
-                const txResult = response;
-                const bond = txResult.logs && txResult.logs[0].events.filter((i) => i.type === 'bond');
-                const transfer = txResult.logs && txResult.logs[0].events.filter((i) => i.type === 'transfer');
-                if (!transfer)
-                    throw new Error(`Failed to get transaction logs (tx-hash: ${txId})`);
-                const sender = (_a = transfer[0].attributes.find((attr) => attr.key === 'sender')) === null || _a === void 0 ? void 0 : _a.value;
-                const senderAmount = transfer[0].attributes.filter((attr) => attr.key === 'amount')[1].value;
-                const regex = /[a-zA-Z]+$/;
-                const match = senderAmount.match(regex);
-                const asset = match ? match[0] : null;
-                const senderAsset = asset === 'rune' ? AssetRuneNative : xchainUtil.assetFromStringEx(`${asset}`);
-                const senderAddress = sender ? sender : address;
-                const message = txResult.logs && txResult.logs[0].events.filter((i) => i.type === 'message');
-                const coinSpent = txResult.logs && txResult.logs[0].events.filter((i) => i.type === 'coin_spent');
-                if (!message || !coinSpent)
-                    throw new Error(`Failed to get transaction logs (tx-hash: ${txId})`);
-                const action = (_b = message[0].attributes.find((attr) => attr.key === 'action')) === null || _b === void 0 ? void 0 : _b.value;
-                if (!bond)
-                    throw new Error(`Failed to get transaction logs (tx-hash: ${txId})`);
-                // Rune only transactions
-                if (action === 'send' || bond[0].type === 'bond') {
-                    const assetTo = AssetRuneNative;
-                    const txData = txResult && txResult.logs
-                        ? getDepositTxDataFromLogs(txResult.logs, `${senderAddress}`, senderAsset, assetTo)
+            const txResult = yield this.fetchTransaction(txId);
+            if (txResult && txResult.logs) {
+                // extract values from the response
+                const transferEvent = (_a = txResult.logs[0].events) === null || _a === void 0 ? void 0 : _a.find((event) => event.type === 'transfer');
+                const messageEvent = (_b = txResult.logs[0].events) === null || _b === void 0 ? void 0 : _b.find((event) => event.type === 'message');
+                if (!transferEvent || !messageEvent) {
+                    throw new Error('Invalid transaction data');
+                }
+                const attributeGroups = {};
+                for (const attr of transferEvent.attributes) {
+                    if (!attributeGroups[attr.key]) {
+                        attributeGroups[attr.key] = [];
+                    }
+                    attributeGroups[attr.key].push(attr.value);
+                }
+                const assetAmount = attributeGroups['amount'][1]
+                    ? attributeGroups['amount'][1].split(/(?<=\d)(?=\D)/).filter(Boolean)[0]
+                    : attributeGroups['amount'][0].split(/(?<=\d)(?=\D)/).filter(Boolean)[0];
+                const assetString = attributeGroups['amount'][1]
+                    ? attributeGroups['amount'][1]
+                        .split(/(?<=\d)(?=\D)/)
+                        .filter(Boolean)[1]
+                        .replace(/[a-z]/g, (letter) => letter.toUpperCase())
+                    : attributeGroups['amount'][0]
+                        .split(/(?<=\d)(?=\D)/)
+                        .filter(Boolean)[1]
+                        .replace(/[a-z]/g, (letter) => letter.toUpperCase());
+                const fromAddress = ((_c = transferEvent.attributes.find((attr) => attr.key === 'sender')) === null || _c === void 0 ? void 0 : _c.value)
+                    ? (_d = transferEvent.attributes.find((attr) => attr.key === 'sender')) === null || _d === void 0 ? void 0 : _d.value
+                    : address;
+                const memo = ((_e = txResult.tx) === null || _e === void 0 ? void 0 : _e.body) ? txResult.tx.body.memo.split(':') : '';
+                const toAddress = memo[2] ? memo[2] : '';
+                const toAsset = memo[1] ? xchainUtil.assetFromStringEx(memo[1]) : AssetRuneNative;
+                const date = new Date(txResult.timestamp);
+                const typeString = (_f = messageEvent.attributes.find((attr) => attr.key === 'action')) === null || _f === void 0 ? void 0 : _f.value;
+                const hash = txResult.txhash;
+                if (assetString && hash && fromAddress && typeString) {
+                    const fromAsset = assetString === 'RUNE' ? AssetRuneNative : xchainUtil.assetFromStringEx(assetString);
+                    const txData = txResult && txResult.raw_log
+                        ? getDepositTxDataFromLogs(txResult.logs, `${fromAddress}`, fromAsset, toAsset)
                         : null;
-                    //console.log(JSON.stringify(txData, null, 2))
                     if (!txData)
                         throw new Error(`Failed to get transaction data (tx-hash: ${txId})`);
-                    const { from, to, type } = txData;
-                    return {
-                        hash: txId,
-                        asset: senderAsset,
-                        from,
-                        to,
-                        date: new Date(txResult.timestamp),
-                        type,
+                    if (isAssetRuneNative(toAsset) || toAsset.synth) {
+                        const { from, to, type } = txData;
+                        const tx = {
+                            asset: fromAsset,
+                            from: from,
+                            to: to,
+                            date: date,
+                            type: type,
+                            hash: hash,
+                        };
+                        return tx;
+                    }
+                    else {
+                        const tx = {
+                            asset: fromAsset,
+                            from: [{ from: fromAddress, amount: xchainUtil.baseAmount(assetAmount), asset: fromAsset }],
+                            to: [{ to: toAddress, amount: xchainUtil.baseAmount(memo[3]), asset: toAsset }],
+                            date: date,
+                            type: xchainClient.TxType.Transfer,
+                            hash: hash,
+                        };
+                        return tx;
+                    }
+                }
+                else {
+                    const tx = {
+                        asset: {
+                            chain: '',
+                            symbol: '',
+                            ticker: '',
+                            synth: false,
+                        },
+                        from: [],
+                        to: [],
+                        date: new Date(),
+                        type: xchainClient.TxType.Transfer,
+                        hash: '',
                     };
+                    return tx;
                 }
-                // synths and other tx types
-                const messageBody = JSON.stringify((_c = txResult.tx) === null || _c === void 0 ? void 0 : _c.body.messages).split(':');
-                const assetTo = xchainUtil.assetFromStringEx(messageBody[7]);
-                const txData = txResult && txResult.logs
-                    ? getDepositTxDataFromLogs(txResult.logs, `${senderAddress}`, senderAsset, assetTo)
-                    : null;
-                if (!txData)
-                    throw new Error(`Failed to get transaction data (tx-hash: ${txId})`);
-                const { from, to, type } = txData;
-                return {
-                    hash: txId,
-                    asset: senderAsset,
-                    from,
-                    to,
-                    date: new Date(txResult.timestamp),
-                    type,
-                };
             }
             else {
                 return yield this.getTransactionDataThornode(txId);