@xchainjs/xchain-aggregator 2.0.35 → 2.1.0

package/lib/index.esm.js

@@ -6081,36 +6081,36 @@ function requireIsRetryAllowed () {
 var isRetryAllowedExports = requireIsRetryAllowed();
 var isRetryAllowed = /*@__PURE__*/getDefaultExportFromCjs(isRetryAllowedExports);
 
-function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+function asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
 
-function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+function _asyncToGenerator$1(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
 
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+function ownKeys$1(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
 
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+function _objectSpread$1(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys$1(Object(source), true).forEach(function (key) { _defineProperty$1(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys$1(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
 
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-var namespace = 'axios-retry';
+function _defineProperty$1(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+var namespace$1 = 'axios-retry';
 /**
  * @param  {Error}  error
  * @return {boolean}
  */
 
-function isNetworkError(error) {
+function isNetworkError$1(error) {
   var CODE_EXCLUDE_LIST = ['ERR_CANCELED', 'ECONNABORTED'];
   return !error.response && Boolean(error.code) && // Prevents retrying cancelled requests
   !CODE_EXCLUDE_LIST.includes(error.code) && // Prevents retrying timed out & cancelled requests
   isRetryAllowed(error) // Prevents retrying unsafe errors
   ;
 }
-var SAFE_HTTP_METHODS = ['get', 'head', 'options'];
-var IDEMPOTENT_HTTP_METHODS = SAFE_HTTP_METHODS.concat(['put', 'delete']);
+var SAFE_HTTP_METHODS$1 = ['get', 'head', 'options'];
+var IDEMPOTENT_HTTP_METHODS$1 = SAFE_HTTP_METHODS$1.concat(['put', 'delete']);
 /**
  * @param  {Error}  error
  * @return {boolean}
  */
 
-function isRetryableError(error) {
+function isRetryableError$1(error) {
   return error.code !== 'ECONNABORTED' && (!error.response || error.response.status >= 500 && error.response.status <= 599);
 }
 /**
@@ -6118,40 +6118,40 @@ function isRetryableError(error) {
  * @return {boolean}
  */
 
-function isSafeRequestError(error) {
+function isSafeRequestError$1(error) {
   if (!error.config) {
     // Cannot determine if the request can be retried
     return false;
   }
 
-  return isRetryableError(error) && SAFE_HTTP_METHODS.indexOf(error.config.method) !== -1;
+  return isRetryableError$1(error) && SAFE_HTTP_METHODS$1.indexOf(error.config.method) !== -1;
 }
 /**
  * @param  {Error}  error
  * @return {boolean}
  */
 
-function isIdempotentRequestError(error) {
+function isIdempotentRequestError$1(error) {
   if (!error.config) {
     // Cannot determine if the request can be retried
     return false;
   }
 
-  return isRetryableError(error) && IDEMPOTENT_HTTP_METHODS.indexOf(error.config.method) !== -1;
+  return isRetryableError$1(error) && IDEMPOTENT_HTTP_METHODS$1.indexOf(error.config.method) !== -1;
 }
 /**
  * @param  {Error}  error
  * @return {boolean}
  */
 
-function isNetworkOrIdempotentRequestError(error) {
-  return isNetworkError(error) || isIdempotentRequestError(error);
+function isNetworkOrIdempotentRequestError$1(error) {
+  return isNetworkError$1(error) || isIdempotentRequestError$1(error);
 }
 /**
  * @return {number} - delay in milliseconds, always 0
  */
 
-function noDelay() {
+function noDelay$1() {
   return 0;
 }
 /**
@@ -6164,7 +6164,7 @@ function noDelay() {
  */
 
 
-function exponentialDelay() {
+function exponentialDelay$1() {
   var retryNumber = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
   var delayFactor = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 100;
   var delay = Math.pow(2, retryNumber) * delayFactor;
@@ -6174,10 +6174,10 @@ function exponentialDelay() {
 }
 /** @type {IAxiosRetryConfig} */
 
-var DEFAULT_OPTIONS = {
+var DEFAULT_OPTIONS$1 = {
   retries: 3,
-  retryCondition: isNetworkOrIdempotentRequestError,
-  retryDelay: noDelay,
+  retryCondition: isNetworkOrIdempotentRequestError$1,
+  retryDelay: noDelay$1,
   shouldResetTimeout: false,
   onRetry: () => {}
 };
@@ -6188,8 +6188,8 @@ var DEFAULT_OPTIONS = {
  * @return {IAxiosRetryConfigExtended}
  */
 
-function getRequestOptions(config, defaultOptions) {
-  return _objectSpread(_objectSpread(_objectSpread({}, DEFAULT_OPTIONS), defaultOptions), config[namespace]);
+function getRequestOptions$1(config, defaultOptions) {
+  return _objectSpread$1(_objectSpread$1(_objectSpread$1({}, DEFAULT_OPTIONS$1), defaultOptions), config[namespace$1]);
 }
 /**
  * Initializes and returns the retry state for the given request/config
@@ -6199,10 +6199,10 @@ function getRequestOptions(config, defaultOptions) {
  */
 
 
-function getCurrentState(config, defaultOptions) {
-  var currentState = getRequestOptions(config, defaultOptions);
+function getCurrentState$1(config, defaultOptions) {
+  var currentState = getRequestOptions$1(config, defaultOptions);
   currentState.retryCount = currentState.retryCount || 0;
-  config[namespace] = currentState;
+  config[namespace$1] = currentState;
   return currentState;
 }
 /**
@@ -6211,7 +6211,7 @@ function getCurrentState(config, defaultOptions) {
  */
 
 
-function fixConfig(axios, config) {
+function fixConfig$1(axios, config) {
   if (axios.defaults.agent === config.agent) {
     delete config.agent;
   }
@@ -6232,8 +6232,8 @@ function fixConfig(axios, config) {
  */
 
 
-function shouldRetry(_x, _x2) {
-  return _shouldRetry.apply(this, arguments);
+function shouldRetry$1(_x, _x2) {
+  return _shouldRetry$1.apply(this, arguments);
 }
 /**
  * Adds response interceptors to an axios instance to retry requests failed due to network issues
@@ -6293,8 +6293,8 @@ function shouldRetry(_x, _x2) {
  */
 
 
-function _shouldRetry() {
-  _shouldRetry = _asyncToGenerator(function* (currentState, error) {
+function _shouldRetry$1() {
+  _shouldRetry$1 = _asyncToGenerator$1(function* (currentState, error) {
     var {
       retries,
       retryCondition
@@ -6313,17 +6313,17 @@ function _shouldRetry() {
 
     return shouldRetryOrPromise;
   });
-  return _shouldRetry.apply(this, arguments);
+  return _shouldRetry$1.apply(this, arguments);
 }
 
-function axiosRetry(axios, defaultOptions) {
+function axiosRetry$1(axios, defaultOptions) {
   var requestInterceptorId = axios.interceptors.request.use(config => {
-    var currentState = getCurrentState(config, defaultOptions);
+    var currentState = getCurrentState$1(config, defaultOptions);
     currentState.lastRequestTime = Date.now();
     return config;
   });
   var responseInterceptorId = axios.interceptors.response.use(null, /*#__PURE__*/function () {
-    var _ref = _asyncToGenerator(function* (error) {
+    var _ref = _asyncToGenerator$1(function* (error) {
       var {
         config
       } = error; // If we have no information to retry the request
@@ -6332,9 +6332,9 @@ function axiosRetry(axios, defaultOptions) {
         return Promise.reject(error);
       }
 
-      var currentState = getCurrentState(config, defaultOptions);
+      var currentState = getCurrentState$1(config, defaultOptions);
 
-      if (yield shouldRetry(currentState, error)) {
+      if (yield shouldRetry$1(currentState, error)) {
         currentState.retryCount += 1;
         var {
           retryDelay,
@@ -6344,7 +6344,7 @@ function axiosRetry(axios, defaultOptions) {
         var delay = retryDelay(currentState.retryCount, error); // Axios fails merging this configuration to the default configuration because it has an issue
         // with circular structures: https://github.com/mzabriskie/axios/issues/370
 
-        fixConfig(axios, config);
+        fixConfig$1(axios, config);
 
         if (!shouldResetTimeout && config.timeout && currentState.lastRequestTime) {
           var lastRequestDuration = Date.now() - currentState.lastRequestTime;
@@ -6375,12 +6375,12 @@ function axiosRetry(axios, defaultOptions) {
   };
 } // Compatibility with CommonJS
 
-axiosRetry.isNetworkError = isNetworkError;
-axiosRetry.isSafeRequestError = isSafeRequestError;
-axiosRetry.isIdempotentRequestError = isIdempotentRequestError;
-axiosRetry.isNetworkOrIdempotentRequestError = isNetworkOrIdempotentRequestError;
-axiosRetry.exponentialDelay = exponentialDelay;
-axiosRetry.isRetryableError = isRetryableError;
+axiosRetry$1.isNetworkError = isNetworkError$1;
+axiosRetry$1.isSafeRequestError = isSafeRequestError$1;
+axiosRetry$1.isIdempotentRequestError = isIdempotentRequestError$1;
+axiosRetry$1.isNetworkOrIdempotentRequestError = isNetworkOrIdempotentRequestError$1;
+axiosRetry$1.exponentialDelay = exponentialDelay$1;
+axiosRetry$1.isRetryableError = isRetryableError$1;
 
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
@@ -6444,7 +6444,7 @@ let MidgardApi$1 = class MidgardApi {
     constructor(network = Network.Mainnet, config) {
         this.network = network;
         this.config = config !== null && config !== void 0 ? config : defaultMidgardConfig$1[this.network];
-        axiosRetry(axios, { retries: this.config.apiRetries, retryDelay: axiosRetry.exponentialDelay });
+        axiosRetry$1(axios, { retries: this.config.apiRetries, retryDelay: axiosRetry$1.exponentialDelay });
         this.midgardClients = this.config.midgardBaseUrls.map((url) => new MidgardApi$2(new Configuration$1({ basePath: url })));
     }
     /**
@@ -8871,6 +8871,307 @@ class MidgardApi extends DefaultApi {
     }
 }
 
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+var namespace = 'axios-retry';
+/**
+ * @param  {Error}  error
+ * @return {boolean}
+ */
+
+function isNetworkError(error) {
+  var CODE_EXCLUDE_LIST = ['ERR_CANCELED', 'ECONNABORTED'];
+  return !error.response && Boolean(error.code) && // Prevents retrying cancelled requests
+  !CODE_EXCLUDE_LIST.includes(error.code) && // Prevents retrying timed out & cancelled requests
+  isRetryAllowed(error) // Prevents retrying unsafe errors
+  ;
+}
+var SAFE_HTTP_METHODS = ['get', 'head', 'options'];
+var IDEMPOTENT_HTTP_METHODS = SAFE_HTTP_METHODS.concat(['put', 'delete']);
+/**
+ * @param  {Error}  error
+ * @return {boolean}
+ */
+
+function isRetryableError(error) {
+  return error.code !== 'ECONNABORTED' && (!error.response || error.response.status >= 500 && error.response.status <= 599);
+}
+/**
+ * @param  {Error}  error
+ * @return {boolean}
+ */
+
+function isSafeRequestError(error) {
+  if (!error.config) {
+    // Cannot determine if the request can be retried
+    return false;
+  }
+
+  return isRetryableError(error) && SAFE_HTTP_METHODS.indexOf(error.config.method) !== -1;
+}
+/**
+ * @param  {Error}  error
+ * @return {boolean}
+ */
+
+function isIdempotentRequestError(error) {
+  if (!error.config) {
+    // Cannot determine if the request can be retried
+    return false;
+  }
+
+  return isRetryableError(error) && IDEMPOTENT_HTTP_METHODS.indexOf(error.config.method) !== -1;
+}
+/**
+ * @param  {Error}  error
+ * @return {boolean}
+ */
+
+function isNetworkOrIdempotentRequestError(error) {
+  return isNetworkError(error) || isIdempotentRequestError(error);
+}
+/**
+ * @return {number} - delay in milliseconds, always 0
+ */
+
+function noDelay() {
+  return 0;
+}
+/**
+ * Set delayFactor 1000 for an exponential delay to occur on the order
+ * of seconds
+ * @param  {number} [retryNumber=0]
+ * @param  {Error}  error - unused; for existing API of retryDelay callback
+ * @param  {number} [delayFactor=100] milliseconds
+ * @return {number} - delay in milliseconds
+ */
+
+
+function exponentialDelay() {
+  var retryNumber = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+  var delayFactor = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 100;
+  var delay = Math.pow(2, retryNumber) * delayFactor;
+  var randomSum = delay * 0.2 * Math.random(); // 0-20% of the delay
+
+  return delay + randomSum;
+}
+/** @type {IAxiosRetryConfig} */
+
+var DEFAULT_OPTIONS = {
+  retries: 3,
+  retryCondition: isNetworkOrIdempotentRequestError,
+  retryDelay: noDelay,
+  shouldResetTimeout: false,
+  onRetry: () => {}
+};
+/**
+ * Returns the axios-retry options for the current request
+ * @param  {AxiosRequestConfig} config
+ * @param  {IAxiosRetryConfig} defaultOptions
+ * @return {IAxiosRetryConfigExtended}
+ */
+
+function getRequestOptions(config, defaultOptions) {
+  return _objectSpread(_objectSpread(_objectSpread({}, DEFAULT_OPTIONS), defaultOptions), config[namespace]);
+}
+/**
+ * Initializes and returns the retry state for the given request/config
+ * @param  {AxiosRequestConfig} config
+ * @param  {IAxiosRetryConfig} defaultOptions
+ * @return {IAxiosRetryConfigExtended}
+ */
+
+
+function getCurrentState(config, defaultOptions) {
+  var currentState = getRequestOptions(config, defaultOptions);
+  currentState.retryCount = currentState.retryCount || 0;
+  config[namespace] = currentState;
+  return currentState;
+}
+/**
+ * @param  {Axios} axios
+ * @param  {AxiosRequestConfig} config
+ */
+
+
+function fixConfig(axios, config) {
+  if (axios.defaults.agent === config.agent) {
+    delete config.agent;
+  }
+
+  if (axios.defaults.httpAgent === config.httpAgent) {
+    delete config.httpAgent;
+  }
+
+  if (axios.defaults.httpsAgent === config.httpsAgent) {
+    delete config.httpsAgent;
+  }
+}
+/**
+ * Checks retryCondition if request can be retried. Handles it's returning value or Promise.
+ * @param  {IAxiosRetryConfigExtended} currentState
+ * @param  {Error} error
+ * @return {Promise<boolean>}
+ */
+
+
+function shouldRetry(_x, _x2) {
+  return _shouldRetry.apply(this, arguments);
+}
+/**
+ * Adds response interceptors to an axios instance to retry requests failed due to network issues
+ *
+ * @example
+ *
+ * import axios from 'axios';
+ *
+ * axiosRetry(axios, { retries: 3 });
+ *
+ * axios.get('http://example.com/test') // The first request fails and the second returns 'ok'
+ *   .then(result => {
+ *     result.data; // 'ok'
+ *   });
+ *
+ * // Exponential back-off retry delay between requests
+ * axiosRetry(axios, { retryDelay : axiosRetry.exponentialDelay});
+ *
+ * // Custom retry delay
+ * axiosRetry(axios, { retryDelay : (retryCount) => {
+ *   return retryCount * 1000;
+ * }});
+ *
+ * // Also works with custom axios instances
+ * const client = axios.create({ baseURL: 'http://example.com' });
+ * axiosRetry(client, { retries: 3 });
+ *
+ * client.get('/test') // The first request fails and the second returns 'ok'
+ *   .then(result => {
+ *     result.data; // 'ok'
+ *   });
+ *
+ * // Allows request-specific configuration
+ * client
+ *   .get('/test', {
+ *     'axios-retry': {
+ *       retries: 0
+ *     }
+ *   })
+ *   .catch(error => { // The first request fails
+ *     error !== undefined
+ *   });
+ *
+ * @param {Axios} axios An axios instance (the axios object or one created from axios.create)
+ * @param {Object} [defaultOptions]
+ * @param {number} [defaultOptions.retries=3] Number of retries
+ * @param {boolean} [defaultOptions.shouldResetTimeout=false]
+ *        Defines if the timeout should be reset between retries
+ * @param {Function} [defaultOptions.retryCondition=isNetworkOrIdempotentRequestError]
+ *        A function to determine if the error can be retried
+ * @param {Function} [defaultOptions.retryDelay=noDelay]
+ *        A function to determine the delay between retry requests
+ * @param {Function} [defaultOptions.onRetry=()=>{}]
+ *        A function to get notified when a retry occurs
+ * @return {{ requestInterceptorId: number, responseInterceptorId: number }}
+ *        The ids of the interceptors added to the request and to the response (so they can be ejected at a later time)
+ */
+
+
+function _shouldRetry() {
+  _shouldRetry = _asyncToGenerator(function* (currentState, error) {
+    var {
+      retries,
+      retryCondition
+    } = currentState;
+    var shouldRetryOrPromise = currentState.retryCount < retries && retryCondition(error); // This could be a promise
+
+    if (typeof shouldRetryOrPromise === 'object') {
+      try {
+        var shouldRetryPromiseResult = yield shouldRetryOrPromise; // keep return true unless shouldRetryPromiseResult return false for compatibility
+
+        return shouldRetryPromiseResult !== false;
+      } catch (_err) {
+        return false;
+      }
+    }
+
+    return shouldRetryOrPromise;
+  });
+  return _shouldRetry.apply(this, arguments);
+}
+
+function axiosRetry(axios, defaultOptions) {
+  var requestInterceptorId = axios.interceptors.request.use(config => {
+    var currentState = getCurrentState(config, defaultOptions);
+    currentState.lastRequestTime = Date.now();
+    return config;
+  });
+  var responseInterceptorId = axios.interceptors.response.use(null, /*#__PURE__*/function () {
+    var _ref = _asyncToGenerator(function* (error) {
+      var {
+        config
+      } = error; // If we have no information to retry the request
+
+      if (!config) {
+        return Promise.reject(error);
+      }
+
+      var currentState = getCurrentState(config, defaultOptions);
+
+      if (yield shouldRetry(currentState, error)) {
+        currentState.retryCount += 1;
+        var {
+          retryDelay,
+          shouldResetTimeout,
+          onRetry
+        } = currentState;
+        var delay = retryDelay(currentState.retryCount, error); // Axios fails merging this configuration to the default configuration because it has an issue
+        // with circular structures: https://github.com/mzabriskie/axios/issues/370
+
+        fixConfig(axios, config);
+
+        if (!shouldResetTimeout && config.timeout && currentState.lastRequestTime) {
+          var lastRequestDuration = Date.now() - currentState.lastRequestTime;
+          var timeout = config.timeout - lastRequestDuration - delay;
+
+          if (timeout <= 0) {
+            return Promise.reject(error);
+          }
+
+          config.timeout = timeout;
+        }
+
+        config.transformRequest = [data => data];
+        yield onRetry(currentState.retryCount, error, config);
+        return new Promise(resolve => setTimeout(() => resolve(axios(config)), delay));
+      }
+
+      return Promise.reject(error);
+    });
+
+    return function (_x3) {
+      return _ref.apply(this, arguments);
+    };
+  }());
+  return {
+    requestInterceptorId,
+    responseInterceptorId
+  };
+} // Compatibility with CommonJS
+
+axiosRetry.isNetworkError = isNetworkError;
+axiosRetry.isSafeRequestError = isSafeRequestError;
+axiosRetry.isIdempotentRequestError = isIdempotentRequestError;
+axiosRetry.isNetworkOrIdempotentRequestError = isNetworkOrIdempotentRequestError;
+axiosRetry.exponentialDelay = exponentialDelay;
+axiosRetry.isRetryableError = isRetryableError;
+
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
 

package/lib/index.js

@@ -6083,36 +6083,36 @@ function requireIsRetryAllowed () {
 var isRetryAllowedExports = requireIsRetryAllowed();
 var isRetryAllowed = /*@__PURE__*/getDefaultExportFromCjs(isRetryAllowedExports);
 
-function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+function asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
 
-function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+function _asyncToGenerator$1(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
 
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+function ownKeys$1(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
 
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+function _objectSpread$1(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys$1(Object(source), true).forEach(function (key) { _defineProperty$1(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys$1(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
 
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-var namespace = 'axios-retry';
+function _defineProperty$1(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+var namespace$1 = 'axios-retry';
 /**
  * @param  {Error}  error
  * @return {boolean}
  */
 
-function isNetworkError(error) {
+function isNetworkError$1(error) {
   var CODE_EXCLUDE_LIST = ['ERR_CANCELED', 'ECONNABORTED'];
   return !error.response && Boolean(error.code) && // Prevents retrying cancelled requests
   !CODE_EXCLUDE_LIST.includes(error.code) && // Prevents retrying timed out & cancelled requests
   isRetryAllowed(error) // Prevents retrying unsafe errors
   ;
 }
-var SAFE_HTTP_METHODS = ['get', 'head', 'options'];
-var IDEMPOTENT_HTTP_METHODS = SAFE_HTTP_METHODS.concat(['put', 'delete']);
+var SAFE_HTTP_METHODS$1 = ['get', 'head', 'options'];
+var IDEMPOTENT_HTTP_METHODS$1 = SAFE_HTTP_METHODS$1.concat(['put', 'delete']);
 /**
  * @param  {Error}  error
  * @return {boolean}
  */
 
-function isRetryableError(error) {
+function isRetryableError$1(error) {
   return error.code !== 'ECONNABORTED' && (!error.response || error.response.status >= 500 && error.response.status <= 599);
 }
 /**
@@ -6120,40 +6120,40 @@ function isRetryableError(error) {
  * @return {boolean}
  */
 
-function isSafeRequestError(error) {
+function isSafeRequestError$1(error) {
   if (!error.config) {
     // Cannot determine if the request can be retried
     return false;
   }
 
-  return isRetryableError(error) && SAFE_HTTP_METHODS.indexOf(error.config.method) !== -1;
+  return isRetryableError$1(error) && SAFE_HTTP_METHODS$1.indexOf(error.config.method) !== -1;
 }
 /**
  * @param  {Error}  error
  * @return {boolean}
  */
 
-function isIdempotentRequestError(error) {
+function isIdempotentRequestError$1(error) {
   if (!error.config) {
     // Cannot determine if the request can be retried
     return false;
   }
 
-  return isRetryableError(error) && IDEMPOTENT_HTTP_METHODS.indexOf(error.config.method) !== -1;
+  return isRetryableError$1(error) && IDEMPOTENT_HTTP_METHODS$1.indexOf(error.config.method) !== -1;
 }
 /**
  * @param  {Error}  error
  * @return {boolean}
  */
 
-function isNetworkOrIdempotentRequestError(error) {
-  return isNetworkError(error) || isIdempotentRequestError(error);
+function isNetworkOrIdempotentRequestError$1(error) {
+  return isNetworkError$1(error) || isIdempotentRequestError$1(error);
 }
 /**
  * @return {number} - delay in milliseconds, always 0
  */
 
-function noDelay() {
+function noDelay$1() {
   return 0;
 }
 /**
@@ -6166,7 +6166,7 @@ function noDelay() {
  */
 
 
-function exponentialDelay() {
+function exponentialDelay$1() {
   var retryNumber = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
   var delayFactor = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 100;
   var delay = Math.pow(2, retryNumber) * delayFactor;
@@ -6176,10 +6176,10 @@ function exponentialDelay() {
 }
 /** @type {IAxiosRetryConfig} */
 
-var DEFAULT_OPTIONS = {
+var DEFAULT_OPTIONS$1 = {
   retries: 3,
-  retryCondition: isNetworkOrIdempotentRequestError,
-  retryDelay: noDelay,
+  retryCondition: isNetworkOrIdempotentRequestError$1,
+  retryDelay: noDelay$1,
   shouldResetTimeout: false,
   onRetry: () => {}
 };
@@ -6190,8 +6190,8 @@ var DEFAULT_OPTIONS = {
  * @return {IAxiosRetryConfigExtended}
  */
 
-function getRequestOptions(config, defaultOptions) {
-  return _objectSpread(_objectSpread(_objectSpread({}, DEFAULT_OPTIONS), defaultOptions), config[namespace]);
+function getRequestOptions$1(config, defaultOptions) {
+  return _objectSpread$1(_objectSpread$1(_objectSpread$1({}, DEFAULT_OPTIONS$1), defaultOptions), config[namespace$1]);
 }
 /**
  * Initializes and returns the retry state for the given request/config
@@ -6201,10 +6201,10 @@ function getRequestOptions(config, defaultOptions) {
  */
 
 
-function getCurrentState(config, defaultOptions) {
-  var currentState = getRequestOptions(config, defaultOptions);
+function getCurrentState$1(config, defaultOptions) {
+  var currentState = getRequestOptions$1(config, defaultOptions);
   currentState.retryCount = currentState.retryCount || 0;
-  config[namespace] = currentState;
+  config[namespace$1] = currentState;
   return currentState;
 }
 /**
@@ -6213,7 +6213,7 @@ function getCurrentState(config, defaultOptions) {
  */
 
 
-function fixConfig(axios, config) {
+function fixConfig$1(axios, config) {
   if (axios.defaults.agent === config.agent) {
     delete config.agent;
   }
@@ -6234,8 +6234,8 @@ function fixConfig(axios, config) {
  */
 
 
-function shouldRetry(_x, _x2) {
-  return _shouldRetry.apply(this, arguments);
+function shouldRetry$1(_x, _x2) {
+  return _shouldRetry$1.apply(this, arguments);
 }
 /**
  * Adds response interceptors to an axios instance to retry requests failed due to network issues
@@ -6295,8 +6295,8 @@ function shouldRetry(_x, _x2) {
  */
 
 
-function _shouldRetry() {
-  _shouldRetry = _asyncToGenerator(function* (currentState, error) {
+function _shouldRetry$1() {
+  _shouldRetry$1 = _asyncToGenerator$1(function* (currentState, error) {
     var {
       retries,
       retryCondition
@@ -6315,17 +6315,17 @@ function _shouldRetry() {
 
     return shouldRetryOrPromise;
   });
-  return _shouldRetry.apply(this, arguments);
+  return _shouldRetry$1.apply(this, arguments);
 }
 
-function axiosRetry(axios, defaultOptions) {
+function axiosRetry$1(axios, defaultOptions) {
   var requestInterceptorId = axios.interceptors.request.use(config => {
-    var currentState = getCurrentState(config, defaultOptions);
+    var currentState = getCurrentState$1(config, defaultOptions);
     currentState.lastRequestTime = Date.now();
     return config;
   });
   var responseInterceptorId = axios.interceptors.response.use(null, /*#__PURE__*/function () {
-    var _ref = _asyncToGenerator(function* (error) {
+    var _ref = _asyncToGenerator$1(function* (error) {
       var {
         config
       } = error; // If we have no information to retry the request
@@ -6334,9 +6334,9 @@ function axiosRetry(axios, defaultOptions) {
         return Promise.reject(error);
       }
 
-      var currentState = getCurrentState(config, defaultOptions);
+      var currentState = getCurrentState$1(config, defaultOptions);
 
-      if (yield shouldRetry(currentState, error)) {
+      if (yield shouldRetry$1(currentState, error)) {
         currentState.retryCount += 1;
         var {
           retryDelay,
@@ -6346,7 +6346,7 @@ function axiosRetry(axios, defaultOptions) {
         var delay = retryDelay(currentState.retryCount, error); // Axios fails merging this configuration to the default configuration because it has an issue
         // with circular structures: https://github.com/mzabriskie/axios/issues/370
 
-        fixConfig(axios, config);
+        fixConfig$1(axios, config);
 
         if (!shouldResetTimeout && config.timeout && currentState.lastRequestTime) {
           var lastRequestDuration = Date.now() - currentState.lastRequestTime;
@@ -6377,12 +6377,12 @@ function axiosRetry(axios, defaultOptions) {
   };
 } // Compatibility with CommonJS
 
-axiosRetry.isNetworkError = isNetworkError;
-axiosRetry.isSafeRequestError = isSafeRequestError;
-axiosRetry.isIdempotentRequestError = isIdempotentRequestError;
-axiosRetry.isNetworkOrIdempotentRequestError = isNetworkOrIdempotentRequestError;
-axiosRetry.exponentialDelay = exponentialDelay;
-axiosRetry.isRetryableError = isRetryableError;
+axiosRetry$1.isNetworkError = isNetworkError$1;
+axiosRetry$1.isSafeRequestError = isSafeRequestError$1;
+axiosRetry$1.isIdempotentRequestError = isIdempotentRequestError$1;
+axiosRetry$1.isNetworkOrIdempotentRequestError = isNetworkOrIdempotentRequestError$1;
+axiosRetry$1.exponentialDelay = exponentialDelay$1;
+axiosRetry$1.isRetryableError = isRetryableError$1;
 
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
@@ -6446,7 +6446,7 @@ let MidgardApi$1 = class MidgardApi {
     constructor(network = xchainClient.Network.Mainnet, config) {
         this.network = network;
         this.config = config !== null && config !== void 0 ? config : defaultMidgardConfig$1[this.network];
-        axiosRetry(axios, { retries: this.config.apiRetries, retryDelay: axiosRetry.exponentialDelay });
+        axiosRetry$1(axios, { retries: this.config.apiRetries, retryDelay: axiosRetry$1.exponentialDelay });
         this.midgardClients = this.config.midgardBaseUrls.map((url) => new MidgardApi$2(new Configuration$1({ basePath: url })));
     }
     /**
@@ -8873,6 +8873,307 @@ class MidgardApi extends DefaultApi {
     }
 }
 
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+var namespace = 'axios-retry';
+/**
+ * @param  {Error}  error
+ * @return {boolean}
+ */
+
+function isNetworkError(error) {
+  var CODE_EXCLUDE_LIST = ['ERR_CANCELED', 'ECONNABORTED'];
+  return !error.response && Boolean(error.code) && // Prevents retrying cancelled requests
+  !CODE_EXCLUDE_LIST.includes(error.code) && // Prevents retrying timed out & cancelled requests
+  isRetryAllowed(error) // Prevents retrying unsafe errors
+  ;
+}
+var SAFE_HTTP_METHODS = ['get', 'head', 'options'];
+var IDEMPOTENT_HTTP_METHODS = SAFE_HTTP_METHODS.concat(['put', 'delete']);
+/**
+ * @param  {Error}  error
+ * @return {boolean}
+ */
+
+function isRetryableError(error) {
+  return error.code !== 'ECONNABORTED' && (!error.response || error.response.status >= 500 && error.response.status <= 599);
+}
+/**
+ * @param  {Error}  error
+ * @return {boolean}
+ */
+
+function isSafeRequestError(error) {
+  if (!error.config) {
+    // Cannot determine if the request can be retried
+    return false;
+  }
+
+  return isRetryableError(error) && SAFE_HTTP_METHODS.indexOf(error.config.method) !== -1;
+}
+/**
+ * @param  {Error}  error
+ * @return {boolean}
+ */
+
+function isIdempotentRequestError(error) {
+  if (!error.config) {
+    // Cannot determine if the request can be retried
+    return false;
+  }
+
+  return isRetryableError(error) && IDEMPOTENT_HTTP_METHODS.indexOf(error.config.method) !== -1;
+}
+/**
+ * @param  {Error}  error
+ * @return {boolean}
+ */
+
+function isNetworkOrIdempotentRequestError(error) {
+  return isNetworkError(error) || isIdempotentRequestError(error);
+}
+/**
+ * @return {number} - delay in milliseconds, always 0
+ */
+
+function noDelay() {
+  return 0;
+}
+/**
+ * Set delayFactor 1000 for an exponential delay to occur on the order
+ * of seconds
+ * @param  {number} [retryNumber=0]
+ * @param  {Error}  error - unused; for existing API of retryDelay callback
+ * @param  {number} [delayFactor=100] milliseconds
+ * @return {number} - delay in milliseconds
+ */
+
+
+function exponentialDelay() {
+  var retryNumber = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+  var delayFactor = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 100;
+  var delay = Math.pow(2, retryNumber) * delayFactor;
+  var randomSum = delay * 0.2 * Math.random(); // 0-20% of the delay
+
+  return delay + randomSum;
+}
+/** @type {IAxiosRetryConfig} */
+
+var DEFAULT_OPTIONS = {
+  retries: 3,
+  retryCondition: isNetworkOrIdempotentRequestError,
+  retryDelay: noDelay,
+  shouldResetTimeout: false,
+  onRetry: () => {}
+};
+/**
+ * Returns the axios-retry options for the current request
+ * @param  {AxiosRequestConfig} config
+ * @param  {IAxiosRetryConfig} defaultOptions
+ * @return {IAxiosRetryConfigExtended}
+ */
+
+function getRequestOptions(config, defaultOptions) {
+  return _objectSpread(_objectSpread(_objectSpread({}, DEFAULT_OPTIONS), defaultOptions), config[namespace]);
+}
+/**
+ * Initializes and returns the retry state for the given request/config
+ * @param  {AxiosRequestConfig} config
+ * @param  {IAxiosRetryConfig} defaultOptions
+ * @return {IAxiosRetryConfigExtended}
+ */
+
+
+function getCurrentState(config, defaultOptions) {
+  var currentState = getRequestOptions(config, defaultOptions);
+  currentState.retryCount = currentState.retryCount || 0;
+  config[namespace] = currentState;
+  return currentState;
+}
+/**
+ * @param  {Axios} axios
+ * @param  {AxiosRequestConfig} config
+ */
+
+
+function fixConfig(axios, config) {
+  if (axios.defaults.agent === config.agent) {
+    delete config.agent;
+  }
+
+  if (axios.defaults.httpAgent === config.httpAgent) {
+    delete config.httpAgent;
+  }
+
+  if (axios.defaults.httpsAgent === config.httpsAgent) {
+    delete config.httpsAgent;
+  }
+}
+/**
+ * Checks retryCondition if request can be retried. Handles it's returning value or Promise.
+ * @param  {IAxiosRetryConfigExtended} currentState
+ * @param  {Error} error
+ * @return {Promise<boolean>}
+ */
+
+
+function shouldRetry(_x, _x2) {
+  return _shouldRetry.apply(this, arguments);
+}
+/**
+ * Adds response interceptors to an axios instance to retry requests failed due to network issues
+ *
+ * @example
+ *
+ * import axios from 'axios';
+ *
+ * axiosRetry(axios, { retries: 3 });
+ *
+ * axios.get('http://example.com/test') // The first request fails and the second returns 'ok'
+ *   .then(result => {
+ *     result.data; // 'ok'
+ *   });
+ *
+ * // Exponential back-off retry delay between requests
+ * axiosRetry(axios, { retryDelay : axiosRetry.exponentialDelay});
+ *
+ * // Custom retry delay
+ * axiosRetry(axios, { retryDelay : (retryCount) => {
+ *   return retryCount * 1000;
+ * }});
+ *
+ * // Also works with custom axios instances
+ * const client = axios.create({ baseURL: 'http://example.com' });
+ * axiosRetry(client, { retries: 3 });
+ *
+ * client.get('/test') // The first request fails and the second returns 'ok'
+ *   .then(result => {
+ *     result.data; // 'ok'
+ *   });
+ *
+ * // Allows request-specific configuration
+ * client
+ *   .get('/test', {
+ *     'axios-retry': {
+ *       retries: 0
+ *     }
+ *   })
+ *   .catch(error => { // The first request fails
+ *     error !== undefined
+ *   });
+ *
+ * @param {Axios} axios An axios instance (the axios object or one created from axios.create)
+ * @param {Object} [defaultOptions]
+ * @param {number} [defaultOptions.retries=3] Number of retries
+ * @param {boolean} [defaultOptions.shouldResetTimeout=false]
+ *        Defines if the timeout should be reset between retries
+ * @param {Function} [defaultOptions.retryCondition=isNetworkOrIdempotentRequestError]
+ *        A function to determine if the error can be retried
+ * @param {Function} [defaultOptions.retryDelay=noDelay]
+ *        A function to determine the delay between retry requests
+ * @param {Function} [defaultOptions.onRetry=()=>{}]
+ *        A function to get notified when a retry occurs
+ * @return {{ requestInterceptorId: number, responseInterceptorId: number }}
+ *        The ids of the interceptors added to the request and to the response (so they can be ejected at a later time)
+ */
+
+
+function _shouldRetry() {
+  _shouldRetry = _asyncToGenerator(function* (currentState, error) {
+    var {
+      retries,
+      retryCondition
+    } = currentState;
+    var shouldRetryOrPromise = currentState.retryCount < retries && retryCondition(error); // This could be a promise
+
+    if (typeof shouldRetryOrPromise === 'object') {
+      try {
+        var shouldRetryPromiseResult = yield shouldRetryOrPromise; // keep return true unless shouldRetryPromiseResult return false for compatibility
+
+        return shouldRetryPromiseResult !== false;
+      } catch (_err) {
+        return false;
+      }
+    }
+
+    return shouldRetryOrPromise;
+  });
+  return _shouldRetry.apply(this, arguments);
+}
+
+function axiosRetry(axios, defaultOptions) {
+  var requestInterceptorId = axios.interceptors.request.use(config => {
+    var currentState = getCurrentState(config, defaultOptions);
+    currentState.lastRequestTime = Date.now();
+    return config;
+  });
+  var responseInterceptorId = axios.interceptors.response.use(null, /*#__PURE__*/function () {
+    var _ref = _asyncToGenerator(function* (error) {
+      var {
+        config
+      } = error; // If we have no information to retry the request
+
+      if (!config) {
+        return Promise.reject(error);
+      }
+
+      var currentState = getCurrentState(config, defaultOptions);
+
+      if (yield shouldRetry(currentState, error)) {
+        currentState.retryCount += 1;
+        var {
+          retryDelay,
+          shouldResetTimeout,
+          onRetry
+        } = currentState;
+        var delay = retryDelay(currentState.retryCount, error); // Axios fails merging this configuration to the default configuration because it has an issue
+        // with circular structures: https://github.com/mzabriskie/axios/issues/370
+
+        fixConfig(axios, config);
+
+        if (!shouldResetTimeout && config.timeout && currentState.lastRequestTime) {
+          var lastRequestDuration = Date.now() - currentState.lastRequestTime;
+          var timeout = config.timeout - lastRequestDuration - delay;
+
+          if (timeout <= 0) {
+            return Promise.reject(error);
+          }
+
+          config.timeout = timeout;
+        }
+
+        config.transformRequest = [data => data];
+        yield onRetry(currentState.retryCount, error, config);
+        return new Promise(resolve => setTimeout(() => resolve(axios(config)), delay));
+      }
+
+      return Promise.reject(error);
+    });
+
+    return function (_x3) {
+      return _ref.apply(this, arguments);
+    };
+  }());
+  return {
+    requestInterceptorId,
+    responseInterceptorId
+  };
+} // Compatibility with CommonJS
+
+axiosRetry.isNetworkError = isNetworkError;
+axiosRetry.isSafeRequestError = isSafeRequestError;
+axiosRetry.isIdempotentRequestError = isIdempotentRequestError;
+axiosRetry.isNetworkOrIdempotentRequestError = isNetworkOrIdempotentRequestError;
+axiosRetry.exponentialDelay = exponentialDelay;
+axiosRetry.isRetryableError = isRetryableError;
+
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@xchainjs/xchain-aggregator",
   "description": "Protocol aggregator to make actions in different protocols",
-  "version": "2.0.35",
+  "version": "2.1.0",
   "license": "MIT",
   "main": "lib/index.js",
   "module": "lib/index.esm.js",
@@ -32,18 +32,18 @@
     "@chainflip/sdk": "1.11.2",
     "@xchainjs/xchain-client": "2.0.10",
     "@xchainjs/xchain-mayachain": "4.1.1",
-    "@xchainjs/xchain-mayachain-amm": "4.1.9",
+    "@xchainjs/xchain-mayachain-amm": "4.1.10",
     "@xchainjs/xchain-mayachain-query": "2.1.6",
     "@xchainjs/xchain-thorchain": "3.0.14",
-    "@xchainjs/xchain-thorchain-amm": "3.0.27",
+    "@xchainjs/xchain-thorchain-amm": "3.0.28",
     "@xchainjs/xchain-thorchain-query": "2.0.16",
     "@xchainjs/xchain-util": "2.0.5",
-    "@xchainjs/xchain-wallet": "2.0.20"
+    "@xchainjs/xchain-wallet": "2.0.21"
   },
   "devDependencies": {
     "@xchainjs/xchain-avax": "2.0.14",
     "@xchainjs/xchain-base": "1.0.14",
-    "@xchainjs/xchain-bitcoin": "2.0.10",
+    "@xchainjs/xchain-bitcoin": "2.1.0",
     "@xchainjs/xchain-bsc": "2.0.15",
     "@xchainjs/xchain-ethereum": "2.0.15",
     "@xchainjs/xchain-kujira": "2.0.10",