@xchainjs/xchain-thorchain 0.28.10 → 0.28.11

package/lib/index.js

@@ -4382,56 +4382,64 @@ var indexMinimal = {};
 
 var minimal$1 = {};
 
-var aspromise = asPromise;
+var aspromise;
+var hasRequiredAspromise;
+
+function requireAspromise () {
+	if (hasRequiredAspromise) return aspromise;
+	hasRequiredAspromise = 1;
+	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}
- */
+	/**
+	 * 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);
-            }
-        }
-    });
+	/**
+	 * 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);
+	            }
+	        }
+	    });
+	}
+	return aspromise;
 }
 
 var base64$1 = {};
@@ -5011,21 +5019,29 @@ function requireFloat () {
 	return float;
 }
 
-var inquire_1 = inquire;
+var inquire_1;
+var hasRequiredInquire;
+
+function requireInquire () {
+	if (hasRequiredInquire) return inquire_1;
+	hasRequiredInquire = 1;
+	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;
+	/**
+	 * 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;
 }
 
 var utf8$2 = {};
@@ -5417,7 +5433,7 @@ 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 = requireBase64();
@@ -5429,7 +5445,7 @@ function requireMinimal () {
 		util.float = requireFloat();
 
 		// requires modules optionally and hides the call from bundlers
-		util.inquire = inquire_1;
+		util.inquire = requireInquire();
 
 		// converts to / from utf8 encoded strings
 		util.utf8 = requireUtf8();
@@ -10432,21 +10448,19 @@ class Client extends xchainClient.BaseXChainClient {
             }
             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
-                        }
+                    try {
+                        const networkObj = fallback[this.network];
+                        const clientUrl = networkObj.node;
+                        const cosmosClient = new xchainCosmos.CosmosSDKClient({
+                            server: Array.isArray(clientUrl) ? clientUrl[0] : clientUrl,
+                            chainId: this.getChainId(this.network),
+                            prefix: getPrefix(this.network),
+                        });
+                        const tx = yield cosmosClient.txsHashGet(txId);
+                        return tx;
+                    }
+                    catch (error) {
+                        // Handle specific error if needed
                     }
                 }
                 return null;