@xchainjs/xchain-thorchain 0.28.0 → 0.28.2

package/lib/index.js

@@ -4283,7 +4283,7 @@ const DEFAULT_EXPLORER_URL = 'https://viewblock.io/thorchain';
 const txUrl = `${DEFAULT_EXPLORER_URL}/tx`;
 const addressUrl = `${DEFAULT_EXPLORER_URL}/address`;
 const RUNE_TICKER = 'RUNE';
-const DECIMAL = 8;
+const RUNE_DECIMAL = 8;
 const DEFAULT_GAS_ADJUSTMENT = 2;
 const DEFAULT_GAS_LIMIT_VALUE = '4000000';
 const DEPOSIT_GAS_LIMIT_VALUE = '600000000';
@@ -4358,205 +4358,239 @@ const AssetRuneERC20Testnet = {
     ticker: RUNE_TICKER,
     synth: false,
 };
+/**
+ * Fall back node's and rpc's
+ */
+const FallBackUrls = [
+    {
+        [lib.Network.Testnet]: {
+            node: ['deprecated'],
+            rpc: ['deprecated'],
+        },
+        [lib.Network.Stagenet]: {
+            node: ['https://stagenet-thornode.ninerealms.com'],
+            rpc: ['https://stagenet-rpc.ninerealms.com'],
+        },
+        [lib.Network.Mainnet]: {
+            node: ['https://thornode-v1.ninerealms.com', 'https://thornode.thorswap.net/'],
+            rpc: ['https://rpc-v1.ninerealms.com', 'https://rpc.thorswap.net'],
+        },
+    },
+];
 
 var indexMinimal = {};
 
 var minimal$1 = {};
 
-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);
-            }
-        }
-    });
-}
+var aspromise;
+var hasRequiredAspromise;
 
-var base64$1 = {};
-
-(function (exports) {
+function requireAspromise () {
+	if (hasRequiredAspromise) return aspromise;
+	hasRequiredAspromise = 1;
+	aspromise = asPromise;
 
 	/**
-	 * 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
+	 * Callback as used by {@link util.asPromise}.
+	 * @typedef asPromiseCallback
+	 * @type {function}
+	 * @param {Error|null} error Error, if any
+	 * @param {...*} params Additional arguments
+	 * @returns {undefined}
 	 */
-	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
+	 * 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
 	 */
-	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;
+	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);
+	            }
 	        }
-	    }
-	    if (j === 1)
-	        throw Error(invalidEncoding);
-	    return offset - start;
-	};
+	    });
+	}
+	return aspromise;
+}
+
+var base64$1 = {};
+
+var hasRequiredBase64;
+
+function requireBase64 () {
+	if (hasRequiredBase64) return base64$1;
+	hasRequiredBase64 = 1;
+	(function (exports) {
 
-	/**
-	 * 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));
+		/**
+		 * 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;
+}
 
 var eventemitter = EventEmitter;
 
@@ -4995,159 +5029,174 @@ function requireInquire () {
 
 var utf8$2 = {};
 
-(function (exports) {
+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;
+		/**
+		 * 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;
 
 	/**
-	 * Calculates the UTF8 byte length of a string.
-	 * @param {string} string String
-	 * @returns {number} Byte length
+	 * An allocator as used by {@link util.pool}.
+	 * @typedef PoolAllocator
+	 * @type {function}
+	 * @param {number} size Buffer size
+	 * @returns {Uint8Array} Buffer
 	 */
-	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
+	 * 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}
 	 */
-	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
+	 * 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
 	 */
-	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;
+	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;
 	        }
-	    }
-	    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 buf = slice.call(slab, offset, offset += size);
+	        if (offset & 7) // align to 32 bit
+	            offset = (offset | 7) + 1;
+	        return buf;
+	    };
+	}
+	return pool_1;
 }
 
 var longbits;
@@ -5367,10 +5416,10 @@ function requireMinimal () {
 		var util = exports;
 
 		// used to return a Promise where callback is omitted
-		util.asPromise = aspromise;
+		util.asPromise = requireAspromise();
 
 		// converts to / from base64 encoded strings
-		util.base64 = base64$1;
+		util.base64 = requireBase64();
 
 		// base class of rpc.Service
 		util.EventEmitter = eventemitter;
@@ -5382,10 +5431,10 @@ function requireMinimal () {
 		util.inquire = requireInquire();
 
 		// converts to / from utf8 encoded strings
-		util.utf8 = utf8$2;
+		util.utf8 = requireUtf8();
 
 		// provides a node-like buffer pool in the browser
-		util.pool = pool_1;
+		util.pool = requirePool();
 
 		// utility to work with the low and high bits of a 64 bit value
 		util.LongBits = requireLongbits();
@@ -9826,14 +9875,14 @@ const getDepositTxDataFromLogs = (logs, address, senderAsset, receiverAsset) =>
         if (type === 'transfer') {
             return attributes.reduce((acc2, { key, value }, index) => {
                 if (index % 3 === 0)
-                    acc2.push({ sender: '', recipient: '', amount: xchainUtil.baseAmount(0, DECIMAL) });
+                    acc2.push({ sender: '', recipient: '', amount: xchainUtil.baseAmount(0, RUNE_DECIMAL) });
                 const newData = acc2[acc2.length - 1];
                 if (key === 'sender')
                     newData.sender = value;
                 if (key === 'recipient')
                     newData.recipient = value;
                 if (key === 'amount')
-                    newData.amount = xchainUtil.baseAmount(value.replace(/rune/, ''), DECIMAL);
+                    newData.amount = xchainUtil.baseAmount(value.replace(/rune/, ''), RUNE_DECIMAL);
                 return acc2;
             }, acc);
         }
@@ -9852,7 +9901,7 @@ const getDepositTxDataFromLogs = (logs, address, senderAsset, receiverAsset) =>
  * @returns {Fees} The default fee.
  */
 const getDefaultFees = () => {
-    const fee = xchainUtil.assetToBase(xchainUtil.assetAmount(0.02 /* 0.02 RUNE */, DECIMAL));
+    const fee = xchainUtil.assetToBase(xchainUtil.assetAmount(0.02 /* 0.02 RUNE */, RUNE_DECIMAL));
     return xchainClient.singleFee(xchainClient.FeeType.FlatFee, fee);
 };
 /**
@@ -10006,7 +10055,7 @@ const getBalance = ({ address, assets, cosmosClient, }) => __awaiter(void 0, voi
     return balances
         .map((balance) => ({
         asset: (balance.denom && assetFromDenom(balance.denom)) || AssetRuneNative,
-        amount: xchainUtil.baseAmount(balance.amount, DECIMAL),
+        amount: xchainUtil.baseAmount(balance.amount, RUNE_DECIMAL),
     }))
         .filter((balance) => !assets || assets.filter((asset) => xchainUtil.assetToString(balance.asset) === xchainUtil.assetToString(asset)).length);
 });
@@ -10351,6 +10400,51 @@ class Client extends xchainClient.BaseXChainClient {
             return getBalance({ address, assets, cosmosClient: this.getCosmosClient() });
         });
     }
+    /**
+     *
+     * @returns asset info
+     */
+    getAssetInfo() {
+        const assetInfo = {
+            asset: AssetRuneNative,
+            decimal: RUNE_DECIMAL,
+        };
+        return assetInfo;
+    }
+    /**
+     *
+     * @param txId - tx hash
+     * @returns txResponse
+     */
+    fetchTransaction(txId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const transaction = yield this.cosmosClient.txsHashGet(txId);
+                return transaction;
+            }
+            catch (error) {
+                for (const fallback of FallBackUrls) {
+                    for (const network of Object.keys(fallback)) {
+                        try {
+                            const networkObj = fallback[network];
+                            const clientUrl = networkObj.node;
+                            const cosmosClient = new xchainCosmos.CosmosSDKClient({
+                                server: Array.isArray(clientUrl) ? clientUrl[0] : clientUrl,
+                                chainId: this.getChainId(network),
+                                prefix: getPrefix(network),
+                            });
+                            const tx = yield cosmosClient.txsHashGet(txId);
+                            return tx;
+                        }
+                        catch (error) {
+                            // Handle specific error if needed
+                        }
+                    }
+                }
+                return null;
+            }
+        });
+    }
     /**
      * Get the transaction details of a given transaction id.
      *
@@ -10360,8 +10454,9 @@ class Client extends xchainClient.BaseXChainClient {
     getTransactionData(txId, address) {
         var _a, _b, _c;
         return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const txResult = yield this.cosmosClient.txsHashGet(txId);
+            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)
@@ -10381,10 +10476,10 @@ class Client extends xchainClient.BaseXChainClient {
                 if (!bond)
                     throw new Error(`Failed to get transaction logs (tx-hash: ${txId})`);
                 // Rune only transactions
-                if (bond[0].type === 'bond' || action === 'send') {
+                if (action === 'send' || bond[0].type === 'bond') {
                     const assetTo = AssetRuneNative;
                     const txData = txResult && txResult.logs
-                        ? getDepositTxDataFromLogs(txResult.logs, senderAddress, senderAsset, assetTo)
+                        ? getDepositTxDataFromLogs(txResult.logs, `${senderAddress}`, senderAsset, assetTo)
                         : null;
                     //console.log(JSON.stringify(txData, null, 2))
                     if (!txData)
@@ -10402,7 +10497,9 @@ class Client extends xchainClient.BaseXChainClient {
                 // 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;
+                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;
@@ -10415,8 +10512,9 @@ class Client extends xchainClient.BaseXChainClient {
                     type,
                 };
             }
-            catch (error) { }
-            return yield this.getTransactionDataThornode(txId);
+            else {
+                return yield this.getTransactionDataThornode(txId);
+            }
         });
     }
     /** This function is used when in bound or outbound tx is not of thorchain
@@ -10445,7 +10543,7 @@ class Client extends xchainClient.BaseXChainClient {
                 asset = xchainUtil.assetFromStringEx(getTx.observed_tx.tx.coins[0].asset);
                 amount = getTx.observed_tx.tx.coins[0].amount;
                 const addressTo = getTx.observed_tx.tx.to_address ? getTx.observed_tx.tx.to_address : 'undefined';
-                const to = [{ to: addressTo, amount: xchainUtil.baseAmount(amount, DECIMAL), asset: asset }];
+                const to = [{ to: addressTo, amount: xchainUtil.baseAmount(amount, RUNE_DECIMAL), asset: asset }];
                 const txData = {
                     hash: txId,
                     asset: senderAsset,
@@ -10461,7 +10559,7 @@ class Client extends xchainClient.BaseXChainClient {
             amount = splitMemo[3];
             const receiverAsset = asset;
             const recieverAmount = amount;
-            const to = [{ to: address, amount: xchainUtil.baseAmount(recieverAmount, DECIMAL), asset: receiverAsset }];
+            const to = [{ to: address, amount: xchainUtil.baseAmount(recieverAmount, RUNE_DECIMAL), asset: receiverAsset }];
             const txData = {
                 hash: txId,
                 asset: senderAsset,
@@ -10492,11 +10590,11 @@ class Client extends xchainClient.BaseXChainClient {
             result.observed_tx.tx.coins.forEach((coin) => {
                 from.push({
                     from: result.observed_tx.tx.from_address,
-                    amount: xchainUtil.baseAmount(coin.amount, DECIMAL),
+                    amount: xchainUtil.baseAmount(coin.amount, RUNE_DECIMAL),
                 });
                 to.push({
                     to: result.observed_tx.tx.to_address,
-                    amount: xchainUtil.baseAmount(coin.amount, DECIMAL),
+                    amount: xchainUtil.baseAmount(coin.amount, RUNE_DECIMAL),
                 });
                 asset = xchainUtil.assetFromString(coin.asset);
             });
@@ -10522,8 +10620,8 @@ class Client extends xchainClient.BaseXChainClient {
         var _a, _b, _c, _d;
         return __awaiter(this, void 0, void 0, function* () {
             const balances = yield this.getBalance(this.getAddress(walletIndex));
-            const runeBalance = (_b = (_a = balances.filter(({ asset }) => isAssetRuneNative(asset))[0]) === null || _a === void 0 ? void 0 : _a.amount) !== null && _b !== void 0 ? _b : xchainUtil.baseAmount(0, DECIMAL);
-            const assetBalance = (_d = (_c = balances.filter(({ asset: assetInList }) => xchainUtil.assetToString(assetInList) === xchainUtil.assetToString(asset))[0]) === null || _c === void 0 ? void 0 : _c.amount) !== null && _d !== void 0 ? _d : xchainUtil.baseAmount(0, DECIMAL);
+            const runeBalance = (_b = (_a = balances.filter(({ asset }) => isAssetRuneNative(asset))[0]) === null || _a === void 0 ? void 0 : _a.amount) !== null && _b !== void 0 ? _b : xchainUtil.baseAmount(0, RUNE_DECIMAL);
+            const assetBalance = (_d = (_c = balances.filter(({ asset: assetInList }) => xchainUtil.assetToString(assetInList) === xchainUtil.assetToString(asset))[0]) === null || _c === void 0 ? void 0 : _c.amount) !== null && _d !== void 0 ? _d : xchainUtil.baseAmount(0, RUNE_DECIMAL);
             const { average: fee } = yield this.getFees();
             if (isAssetRuneNative(asset)) {
                 // amount + fee < runeBalance
@@ -10585,8 +10683,8 @@ class Client extends xchainClient.BaseXChainClient {
         var _a, _b, _c, _d;
         return __awaiter(this, void 0, void 0, function* () {
             const balances = yield this.getBalance(this.getAddress(walletIndex));
-            const runeBalance = (_b = (_a = balances.filter(({ asset }) => isAssetRuneNative(asset))[0]) === null || _a === void 0 ? void 0 : _a.amount) !== null && _b !== void 0 ? _b : xchainUtil.baseAmount(0, DECIMAL);
-            const assetBalance = (_d = (_c = balances.filter(({ asset: assetInList }) => xchainUtil.assetToString(assetInList) === xchainUtil.assetToString(asset))[0]) === null || _c === void 0 ? void 0 : _c.amount) !== null && _d !== void 0 ? _d : xchainUtil.baseAmount(0, DECIMAL);
+            const runeBalance = (_b = (_a = balances.filter(({ asset }) => isAssetRuneNative(asset))[0]) === null || _a === void 0 ? void 0 : _a.amount) !== null && _b !== void 0 ? _b : xchainUtil.baseAmount(0, RUNE_DECIMAL);
+            const assetBalance = (_d = (_c = balances.filter(({ asset: assetInList }) => xchainUtil.assetToString(assetInList) === xchainUtil.assetToString(asset))[0]) === null || _c === void 0 ? void 0 : _c.amount) !== null && _d !== void 0 ? _d : xchainUtil.baseAmount(0, RUNE_DECIMAL);
             const fee = (yield this.getFees()).average;
             if (isAssetRuneNative(asset)) {
                 // amount + fee < runeBalance
@@ -10642,7 +10740,7 @@ class Client extends xchainClient.BaseXChainClient {
      * @param {TxOfflineParams} params The transfer offline options.
      * @returns {string} The signed transaction bytes.
      */
-    transferOffline({ walletIndex = 0, asset = AssetRuneNative, amount, recipient, memo, fromRuneBalance: from_rune_balance, fromAssetBalance: from_asset_balance = xchainUtil.baseAmount(0, DECIMAL), fromAccountNumber = Long$1.ZERO, fromSequence = Long$1.ZERO, gasLimit = new BigNumber(DEFAULT_GAS_LIMIT_VALUE), }) {
+    transferOffline({ walletIndex = 0, asset = AssetRuneNative, amount, recipient, memo, fromRuneBalance: from_rune_balance, fromAssetBalance: from_asset_balance = xchainUtil.baseAmount(0, RUNE_DECIMAL), fromAccountNumber = Long$1.ZERO, fromSequence = Long$1.ZERO, gasLimit = new BigNumber(DEFAULT_GAS_LIMIT_VALUE), }) {
         return __awaiter(this, void 0, void 0, function* () {
             const fee = (yield this.getFees()).average;
             if (isAssetRuneNative(asset)) {
@@ -10723,14 +10821,15 @@ exports.AssetRuneERC20 = AssetRuneERC20;
 exports.AssetRuneERC20Testnet = AssetRuneERC20Testnet;
 exports.AssetRuneNative = AssetRuneNative;
 exports.Client = Client;
-exports.DECIMAL = DECIMAL;
 exports.DEFAULT_GAS_ADJUSTMENT = DEFAULT_GAS_ADJUSTMENT;
 exports.DEFAULT_GAS_LIMIT_VALUE = DEFAULT_GAS_LIMIT_VALUE;
 exports.DEPOSIT_GAS_LIMIT_VALUE = DEPOSIT_GAS_LIMIT_VALUE;
+exports.FallBackUrls = FallBackUrls;
 exports.MAX_PAGES_PER_FUNCTION_CALL = MAX_PAGES_PER_FUNCTION_CALL;
 exports.MAX_TX_COUNT_PER_FUNCTION_CALL = MAX_TX_COUNT_PER_FUNCTION_CALL;
 exports.MAX_TX_COUNT_PER_PAGE = MAX_TX_COUNT_PER_PAGE;
 exports.MsgNativeTx = MsgNativeTx;
+exports.RUNE_DECIMAL = RUNE_DECIMAL;
 exports.RUNE_SYMBOL = RUNE_SYMBOL;
 exports.THORChain = THORChain;
 exports.assetFromDenom = assetFromDenom;