@rango-dev/queue-manager-rango-preset 0.1.10-next.101

package/dist/queue-manager-rango-preset.cjs.development.js

@@ -0,0 +1,2799 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var rangoTypes = require('rango-types');
+var walletsShared = require('@rango-dev/wallets-shared');
+var walletsCore = require('@rango-dev/wallets-core');
+var rangoSdk = require('rango-sdk');
+var queueManagerCore = require('@rango-dev/queue-manager-core');
+var Sentry = require('@sentry/browser');
+var queueManagerReact = require('@rango-dev/queue-manager-react');
+var react = require('react');
+var uuid = require('uuid');
+
+function _regeneratorRuntime() {
+  _regeneratorRuntime = function () {
+    return exports;
+  };
+  var exports = {},
+    Op = Object.prototype,
+    hasOwn = Op.hasOwnProperty,
+    defineProperty = Object.defineProperty || function (obj, key, desc) {
+      obj[key] = desc.value;
+    },
+    $Symbol = "function" == typeof Symbol ? Symbol : {},
+    iteratorSymbol = $Symbol.iterator || "@@iterator",
+    asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator",
+    toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
+  function define(obj, key, value) {
+    return Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: !0,
+      configurable: !0,
+      writable: !0
+    }), obj[key];
+  }
+  try {
+    define({}, "");
+  } catch (err) {
+    define = function (obj, key, value) {
+      return obj[key] = value;
+    };
+  }
+  function wrap(innerFn, outerFn, self, tryLocsList) {
+    var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator,
+      generator = Object.create(protoGenerator.prototype),
+      context = new Context(tryLocsList || []);
+    return defineProperty(generator, "_invoke", {
+      value: makeInvokeMethod(innerFn, self, context)
+    }), generator;
+  }
+  function tryCatch(fn, obj, arg) {
+    try {
+      return {
+        type: "normal",
+        arg: fn.call(obj, arg)
+      };
+    } catch (err) {
+      return {
+        type: "throw",
+        arg: err
+      };
+    }
+  }
+  exports.wrap = wrap;
+  var ContinueSentinel = {};
+  function Generator() {}
+  function GeneratorFunction() {}
+  function GeneratorFunctionPrototype() {}
+  var IteratorPrototype = {};
+  define(IteratorPrototype, iteratorSymbol, function () {
+    return this;
+  });
+  var getProto = Object.getPrototypeOf,
+    NativeIteratorPrototype = getProto && getProto(getProto(values([])));
+  NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol) && (IteratorPrototype = NativeIteratorPrototype);
+  var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype);
+  function defineIteratorMethods(prototype) {
+    ["next", "throw", "return"].forEach(function (method) {
+      define(prototype, method, function (arg) {
+        return this._invoke(method, arg);
+      });
+    });
+  }
+  function AsyncIterator(generator, PromiseImpl) {
+    function invoke(method, arg, resolve, reject) {
+      var record = tryCatch(generator[method], generator, arg);
+      if ("throw" !== record.type) {
+        var result = record.arg,
+          value = result.value;
+        return value && "object" == typeof value && hasOwn.call(value, "__await") ? PromiseImpl.resolve(value.__await).then(function (value) {
+          invoke("next", value, resolve, reject);
+        }, function (err) {
+          invoke("throw", err, resolve, reject);
+        }) : PromiseImpl.resolve(value).then(function (unwrapped) {
+          result.value = unwrapped, resolve(result);
+        }, function (error) {
+          return invoke("throw", error, resolve, reject);
+        });
+      }
+      reject(record.arg);
+    }
+    var previousPromise;
+    defineProperty(this, "_invoke", {
+      value: function (method, arg) {
+        function callInvokeWithMethodAndArg() {
+          return new PromiseImpl(function (resolve, reject) {
+            invoke(method, arg, resolve, reject);
+          });
+        }
+        return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
+      }
+    });
+  }
+  function makeInvokeMethod(innerFn, self, context) {
+    var state = "suspendedStart";
+    return function (method, arg) {
+      if ("executing" === state) throw new Error("Generator is already running");
+      if ("completed" === state) {
+        if ("throw" === method) throw arg;
+        return doneResult();
+      }
+      for (context.method = method, context.arg = arg;;) {
+        var delegate = context.delegate;
+        if (delegate) {
+          var delegateResult = maybeInvokeDelegate(delegate, context);
+          if (delegateResult) {
+            if (delegateResult === ContinueSentinel) continue;
+            return delegateResult;
+          }
+        }
+        if ("next" === context.method) context.sent = context._sent = context.arg;else if ("throw" === context.method) {
+          if ("suspendedStart" === state) throw state = "completed", context.arg;
+          context.dispatchException(context.arg);
+        } else "return" === context.method && context.abrupt("return", context.arg);
+        state = "executing";
+        var record = tryCatch(innerFn, self, context);
+        if ("normal" === record.type) {
+          if (state = context.done ? "completed" : "suspendedYield", record.arg === ContinueSentinel) continue;
+          return {
+            value: record.arg,
+            done: context.done
+          };
+        }
+        "throw" === record.type && (state = "completed", context.method = "throw", context.arg = record.arg);
+      }
+    };
+  }
+  function maybeInvokeDelegate(delegate, context) {
+    var methodName = context.method,
+      method = delegate.iterator[methodName];
+    if (undefined === method) return context.delegate = null, "throw" === methodName && delegate.iterator.return && (context.method = "return", context.arg = undefined, maybeInvokeDelegate(delegate, context), "throw" === context.method) || "return" !== methodName && (context.method = "throw", context.arg = new TypeError("The iterator does not provide a '" + methodName + "' method")), ContinueSentinel;
+    var record = tryCatch(method, delegate.iterator, context.arg);
+    if ("throw" === record.type) return context.method = "throw", context.arg = record.arg, context.delegate = null, ContinueSentinel;
+    var info = record.arg;
+    return info ? info.done ? (context[delegate.resultName] = info.value, context.next = delegate.nextLoc, "return" !== context.method && (context.method = "next", context.arg = undefined), context.delegate = null, ContinueSentinel) : info : (context.method = "throw", context.arg = new TypeError("iterator result is not an object"), context.delegate = null, ContinueSentinel);
+  }
+  function pushTryEntry(locs) {
+    var entry = {
+      tryLoc: locs[0]
+    };
+    1 in locs && (entry.catchLoc = locs[1]), 2 in locs && (entry.finallyLoc = locs[2], entry.afterLoc = locs[3]), this.tryEntries.push(entry);
+  }
+  function resetTryEntry(entry) {
+    var record = entry.completion || {};
+    record.type = "normal", delete record.arg, entry.completion = record;
+  }
+  function Context(tryLocsList) {
+    this.tryEntries = [{
+      tryLoc: "root"
+    }], tryLocsList.forEach(pushTryEntry, this), this.reset(!0);
+  }
+  function values(iterable) {
+    if (iterable) {
+      var iteratorMethod = iterable[iteratorSymbol];
+      if (iteratorMethod) return iteratorMethod.call(iterable);
+      if ("function" == typeof iterable.next) return iterable;
+      if (!isNaN(iterable.length)) {
+        var i = -1,
+          next = function next() {
+            for (; ++i < iterable.length;) if (hasOwn.call(iterable, i)) return next.value = iterable[i], next.done = !1, next;
+            return next.value = undefined, next.done = !0, next;
+          };
+        return next.next = next;
+      }
+    }
+    return {
+      next: doneResult
+    };
+  }
+  function doneResult() {
+    return {
+      value: undefined,
+      done: !0
+    };
+  }
+  return GeneratorFunction.prototype = GeneratorFunctionPrototype, defineProperty(Gp, "constructor", {
+    value: GeneratorFunctionPrototype,
+    configurable: !0
+  }), defineProperty(GeneratorFunctionPrototype, "constructor", {
+    value: GeneratorFunction,
+    configurable: !0
+  }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, toStringTagSymbol, "GeneratorFunction"), exports.isGeneratorFunction = function (genFun) {
+    var ctor = "function" == typeof genFun && genFun.constructor;
+    return !!ctor && (ctor === GeneratorFunction || "GeneratorFunction" === (ctor.displayName || ctor.name));
+  }, exports.mark = function (genFun) {
+    return Object.setPrototypeOf ? Object.setPrototypeOf(genFun, GeneratorFunctionPrototype) : (genFun.__proto__ = GeneratorFunctionPrototype, define(genFun, toStringTagSymbol, "GeneratorFunction")), genFun.prototype = Object.create(Gp), genFun;
+  }, exports.awrap = function (arg) {
+    return {
+      __await: arg
+    };
+  }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, asyncIteratorSymbol, function () {
+    return this;
+  }), exports.AsyncIterator = AsyncIterator, exports.async = function (innerFn, outerFn, self, tryLocsList, PromiseImpl) {
+    void 0 === PromiseImpl && (PromiseImpl = Promise);
+    var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl);
+    return exports.isGeneratorFunction(outerFn) ? iter : iter.next().then(function (result) {
+      return result.done ? result.value : iter.next();
+    });
+  }, defineIteratorMethods(Gp), define(Gp, toStringTagSymbol, "Generator"), define(Gp, iteratorSymbol, function () {
+    return this;
+  }), define(Gp, "toString", function () {
+    return "[object Generator]";
+  }), exports.keys = function (val) {
+    var object = Object(val),
+      keys = [];
+    for (var key in object) keys.push(key);
+    return keys.reverse(), function next() {
+      for (; keys.length;) {
+        var key = keys.pop();
+        if (key in object) return next.value = key, next.done = !1, next;
+      }
+      return next.done = !0, next;
+    };
+  }, exports.values = values, Context.prototype = {
+    constructor: Context,
+    reset: function (skipTempReset) {
+      if (this.prev = 0, this.next = 0, this.sent = this._sent = undefined, this.done = !1, this.delegate = null, this.method = "next", this.arg = undefined, this.tryEntries.forEach(resetTryEntry), !skipTempReset) for (var name in this) "t" === name.charAt(0) && hasOwn.call(this, name) && !isNaN(+name.slice(1)) && (this[name] = undefined);
+    },
+    stop: function () {
+      this.done = !0;
+      var rootRecord = this.tryEntries[0].completion;
+      if ("throw" === rootRecord.type) throw rootRecord.arg;
+      return this.rval;
+    },
+    dispatchException: function (exception) {
+      if (this.done) throw exception;
+      var context = this;
+      function handle(loc, caught) {
+        return record.type = "throw", record.arg = exception, context.next = loc, caught && (context.method = "next", context.arg = undefined), !!caught;
+      }
+      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+        var entry = this.tryEntries[i],
+          record = entry.completion;
+        if ("root" === entry.tryLoc) return handle("end");
+        if (entry.tryLoc <= this.prev) {
+          var hasCatch = hasOwn.call(entry, "catchLoc"),
+            hasFinally = hasOwn.call(entry, "finallyLoc");
+          if (hasCatch && hasFinally) {
+            if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);
+            if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
+          } else if (hasCatch) {
+            if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);
+          } else {
+            if (!hasFinally) throw new Error("try statement without catch or finally");
+            if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
+          }
+        }
+      }
+    },
+    abrupt: function (type, arg) {
+      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+        var entry = this.tryEntries[i];
+        if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) {
+          var finallyEntry = entry;
+          break;
+        }
+      }
+      finallyEntry && ("break" === type || "continue" === type) && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc && (finallyEntry = null);
+      var record = finallyEntry ? finallyEntry.completion : {};
+      return record.type = type, record.arg = arg, finallyEntry ? (this.method = "next", this.next = finallyEntry.finallyLoc, ContinueSentinel) : this.complete(record);
+    },
+    complete: function (record, afterLoc) {
+      if ("throw" === record.type) throw record.arg;
+      return "break" === record.type || "continue" === record.type ? this.next = record.arg : "return" === record.type ? (this.rval = this.arg = record.arg, this.method = "return", this.next = "end") : "normal" === record.type && afterLoc && (this.next = afterLoc), ContinueSentinel;
+    },
+    finish: function (finallyLoc) {
+      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+        var entry = this.tryEntries[i];
+        if (entry.finallyLoc === finallyLoc) return this.complete(entry.completion, entry.afterLoc), resetTryEntry(entry), ContinueSentinel;
+      }
+    },
+    catch: function (tryLoc) {
+      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+        var entry = this.tryEntries[i];
+        if (entry.tryLoc === tryLoc) {
+          var record = entry.completion;
+          if ("throw" === record.type) {
+            var thrown = record.arg;
+            resetTryEntry(entry);
+          }
+          return thrown;
+        }
+      }
+      throw new Error("illegal catch attempt");
+    },
+    delegateYield: function (iterable, resultName, nextLoc) {
+      return this.delegate = {
+        iterator: values(iterable),
+        resultName: resultName,
+        nextLoc: nextLoc
+      }, "next" === this.method && (this.arg = undefined), ContinueSentinel;
+    }
+  }, exports;
+}
+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 _extends() {
+  _extends = Object.assign ? Object.assign.bind() : function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+    return target;
+  };
+  return _extends.apply(this, arguments);
+}
+function _inheritsLoose(subClass, superClass) {
+  subClass.prototype = Object.create(superClass.prototype);
+  subClass.prototype.constructor = subClass;
+  _setPrototypeOf(subClass, superClass);
+}
+function _getPrototypeOf(o) {
+  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
+    return o.__proto__ || Object.getPrototypeOf(o);
+  };
+  return _getPrototypeOf(o);
+}
+function _setPrototypeOf(o, p) {
+  _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
+    o.__proto__ = p;
+    return o;
+  };
+  return _setPrototypeOf(o, p);
+}
+function _isNativeReflectConstruct() {
+  if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+  if (Reflect.construct.sham) return false;
+  if (typeof Proxy === "function") return true;
+  try {
+    Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+function _construct(Parent, args, Class) {
+  if (_isNativeReflectConstruct()) {
+    _construct = Reflect.construct.bind();
+  } else {
+    _construct = function _construct(Parent, args, Class) {
+      var a = [null];
+      a.push.apply(a, args);
+      var Constructor = Function.bind.apply(Parent, a);
+      var instance = new Constructor();
+      if (Class) _setPrototypeOf(instance, Class.prototype);
+      return instance;
+    };
+  }
+  return _construct.apply(null, arguments);
+}
+function _isNativeFunction(fn) {
+  return Function.toString.call(fn).indexOf("[native code]") !== -1;
+}
+function _wrapNativeSuper(Class) {
+  var _cache = typeof Map === "function" ? new Map() : undefined;
+  _wrapNativeSuper = function _wrapNativeSuper(Class) {
+    if (Class === null || !_isNativeFunction(Class)) return Class;
+    if (typeof Class !== "function") {
+      throw new TypeError("Super expression must either be null or a function");
+    }
+    if (typeof _cache !== "undefined") {
+      if (_cache.has(Class)) return _cache.get(Class);
+      _cache.set(Class, Wrapper);
+    }
+    function Wrapper() {
+      return _construct(Class, arguments, _getPrototypeOf(this).constructor);
+    }
+    Wrapper.prototype = Object.create(Class.prototype, {
+      constructor: {
+        value: Wrapper,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      }
+    });
+    return _setPrototypeOf(Wrapper, Class);
+  };
+  return _wrapNativeSuper(Class);
+}
+function _assertThisInitialized(self) {
+  if (self === void 0) {
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  }
+  return self;
+}
+
+var ERROR_ASSERTION_FAILED = 'Assertion failed (Unexpected behaviour)';
+var ERROR_CREATE_TRANSACTION = 'Create transaction failed in Rango Server';
+var ERROR_INPUT_WALLET_NOT_FOUND = 'Input wallet not found';
+var PrettyError = /*#__PURE__*/function (_Error) {
+  _inheritsLoose(PrettyError, _Error);
+  function PrettyError(code, m, root, detail) {
+    var _this;
+    _this = _Error.call(this, m) || this;
+    _this._isPrettyError = true;
+    Object.setPrototypeOf(_assertThisInitialized(_this), PrettyError.prototype);
+    PrettyError.prototype._isPrettyError = true;
+    _this.code = code;
+    _this.detail = detail;
+    _this.root = root;
+    return _this;
+  }
+  PrettyError.isPrettyError = function isPrettyError(obj) {
+    return obj instanceof PrettyError || Object.prototype.hasOwnProperty('_isPrettyError');
+  };
+  var _proto = PrettyError.prototype;
+  _proto.getErrorDetail = function getErrorDetail() {
+    var rawMessage = typeof this.root === 'object' && this.root && this.root.error ? this.root.error : JSON.stringify(this.root);
+    var rootStr = typeof this.root === 'string' ? this.root : this.root instanceof Error ? this.root.message : rawMessage;
+    return {
+      extraMessage: this.message,
+      extraMessageDetail: this.detail || rootStr,
+      extraMessageErrorCode: this.code || null
+    };
+  };
+  PrettyError.AssertionFailed = function AssertionFailed(m) {
+    return new PrettyError('CLIENT_UNEXPECTED_BEHAVIOUR', ERROR_ASSERTION_FAILED, m);
+  };
+  PrettyError.BadStatusCode = function BadStatusCode(message, statusCode) {
+    return new PrettyError('TX_FAIL', message, null, "status code = " + statusCode);
+  };
+  PrettyError.CreateTransaction = function CreateTransaction(detail) {
+    return new PrettyError('FETCH_TX_FAILED', ERROR_CREATE_TRANSACTION, null, detail);
+  };
+  PrettyError.WalletMissing = function WalletMissing() {
+    return new PrettyError('CLIENT_UNEXPECTED_BEHAVIOUR', ERROR_INPUT_WALLET_NOT_FOUND, null, 'Server requested for a blockchain or address not selected by user');
+  };
+  PrettyError.BlockchainMissing = function BlockchainMissing() {
+    return new PrettyError('CLIENT_UNEXPECTED_BEHAVIOUR', ERROR_INPUT_WALLET_NOT_FOUND, null, 'Server requested for a blockchain or address not selected by user');
+  };
+  return PrettyError;
+}( /*#__PURE__*/_wrapNativeSuper(Error));
+function mapAppErrorCodesToAPIErrorCode(errorCode) {
+  var defaultErrorCode = 'CLIENT_UNEXPECTED_BEHAVIOUR';
+  try {
+    if (!errorCode) return defaultErrorCode;
+    if (rangoTypes.isAPIErrorCode(errorCode)) return errorCode;
+    if (rangoTypes.isSignerErrorCode(errorCode)) {
+      var _t;
+      var t = (_t = {}, _t[rangoTypes.SignerErrorCode.REJECTED_BY_USER] = 'USER_REJECT', _t[rangoTypes.SignerErrorCode.SIGN_TX_ERROR] = 'CALL_WALLET_FAILED', _t[rangoTypes.SignerErrorCode.SEND_TX_ERROR] = 'SEND_TX_FAILED', _t[rangoTypes.SignerErrorCode.NOT_IMPLEMENTED] = defaultErrorCode, _t[rangoTypes.SignerErrorCode.OPERATION_UNSUPPORTED] = defaultErrorCode, _t[rangoTypes.SignerErrorCode.UNEXPECTED_BEHAVIOUR] = defaultErrorCode, _t);
+      return t[errorCode];
+    }
+    return defaultErrorCode;
+  } catch (err) {
+    return defaultErrorCode;
+  }
+}
+var prettifyErrorMessage = function prettifyErrorMessage(obj) {
+  if (!obj) return {
+    extraMessage: '',
+    extraMessageErrorCode: null
+  };
+  if (PrettyError.isPrettyError(obj)) return obj.getErrorDetail();
+  if (rangoTypes.SignerError.isSignerError(obj)) {
+    var t = obj.getErrorDetail();
+    return {
+      extraMessage: t.message,
+      extraMessageDetail: t.detail,
+      extraMessageErrorCode: t.code
+    };
+  }
+  if (obj instanceof Error) return {
+    extraMessage: obj.toString(),
+    extraMessageErrorCode: null
+  };
+  if (typeof obj !== 'string') return {
+    extraMessage: JSON.stringify(obj),
+    extraMessageErrorCode: null
+  };
+  return {
+    extraMessage: obj,
+    extraMessageErrorCode: null
+  };
+};
+
+(function (PendingSwapNetworkStatus) {
+  PendingSwapNetworkStatus["WaitingForConnectingWallet"] = "waitingForConnectingWallet";
+  PendingSwapNetworkStatus["WaitingForQueue"] = "waitingForQueue";
+  PendingSwapNetworkStatus["WaitingForNetworkChange"] = "waitingForNetworkChange";
+  PendingSwapNetworkStatus["NetworkChanged"] = "networkChanged";
+})(exports.PendingSwapNetworkStatus || (exports.PendingSwapNetworkStatus = {}));
+(function (MessageSeverity) {
+  MessageSeverity["error"] = "error";
+  MessageSeverity["warning"] = "warning";
+  MessageSeverity["info"] = "info";
+  MessageSeverity["success"] = "success";
+})(exports.MessageSeverity || (exports.MessageSeverity = {}));
+var getCurrentBlockchainOfOrNull = function getCurrentBlockchainOfOrNull(swap, step) {
+  try {
+    return getCurrentBlockchainOf(swap, step);
+  } catch (e) {
+    return null;
+  }
+};
+var getCurrentBlockchainOf = function getCurrentBlockchainOf(swap, step) {
+  var _step$evmTransaction, _step$evmApprovalTran, _step$starknetTransac, _step$starknetApprova, _step$tronTransaction, _step$tronApprovalTra, _step$cosmosTransacti, _step$solanaTransacti, _step$transferTransac;
+  var b1 = ((_step$evmTransaction = step.evmTransaction) == null ? void 0 : _step$evmTransaction.blockChain) || ((_step$evmApprovalTran = step.evmApprovalTransaction) == null ? void 0 : _step$evmApprovalTran.blockChain) || ((_step$starknetTransac = step.starknetTransaction) == null ? void 0 : _step$starknetTransac.blockChain) || ((_step$starknetApprova = step.starknetApprovalTransaction) == null ? void 0 : _step$starknetApprova.blockChain) || ((_step$tronTransaction = step.tronTransaction) == null ? void 0 : _step$tronTransaction.blockChain) || ((_step$tronApprovalTra = step.tronApprovalTransaction) == null ? void 0 : _step$tronApprovalTra.blockChain) || ((_step$cosmosTransacti = step.cosmosTransaction) == null ? void 0 : _step$cosmosTransacti.blockChain) || ((_step$solanaTransacti = step.solanaTransaction) == null ? void 0 : _step$solanaTransacti.blockChain);
+  if (!!b1) return b1;
+  var transferAddress = (_step$transferTransac = step.transferTransaction) == null ? void 0 : _step$transferTransac.fromWalletAddress;
+  if (!transferAddress) throw PrettyError.BlockchainMissing();
+  var blockchain = Object.keys(swap.wallets).find(function (b) {
+    var _swap$wallets$b;
+    return ((_swap$wallets$b = swap.wallets[b]) == null ? void 0 : _swap$wallets$b.address) === transferAddress;
+  }) || null;
+  if (blockchain == null) throw PrettyError.BlockchainMissing();
+  // TODO: check why it returns string
+  return blockchain;
+};
+var getEvmApproveUrl = function getEvmApproveUrl(tx, network, evmBasedBlockchains) {
+  var evmBlochain = evmBasedBlockchains.find(function (blockchain) {
+    return blockchain.name === network;
+  });
+  if (!evmBlochain) {
+    throw Error("unsupported network: " + network + " for getting approve url.");
+  }
+  if (evmBlochain.info.transactionUrl) return evmBlochain.info.transactionUrl.replace('{txHash}', tx.toLowerCase());
+  throw Error("Explorer url for " + network + " is not implemented");
+};
+var getStarknetApproveUrl = function getStarknetApproveUrl(tx) {
+  return 'https://starkscan.co/tx/{txHash}'.replace('{txHash}', tx.toLowerCase());
+};
+var getTronApproveUrl = function getTronApproveUrl(tx) {
+  return 'https://tronscan.org/#/transaction/{txHash}'.replace('{txHash}', tx.toLowerCase());
+};
+function getNextStep(swap, currentStep) {
+  return swap.steps.find(function (step) {
+    return step.status !== 'failed' && step.status !== 'success' && step.id !== currentStep.id;
+  }) || null;
+}
+/**
+ * Returns the wallet address, based on the current step of `PendingSwap`.
+ */
+var getCurrentAddressOf = function getCurrentAddressOf(swap, step) {
+  var _step$evmTransaction2, _step$evmApprovalTran2, _step$tronTransaction2, _step$tronApprovalTra2, _step$starknetTransac2, _step$starknetApprova2, _step$cosmosTransacti2, _step$solanaTransacti2, _step$transferTransac2, _step$transferTransac3;
+  var result = swap.wallets[((_step$evmTransaction2 = step.evmTransaction) == null ? void 0 : _step$evmTransaction2.blockChain) || ''] || swap.wallets[((_step$evmApprovalTran2 = step.evmApprovalTransaction) == null ? void 0 : _step$evmApprovalTran2.blockChain) || ''] || swap.wallets[((_step$tronTransaction2 = step.tronTransaction) == null ? void 0 : _step$tronTransaction2.blockChain) || ''] || swap.wallets[((_step$tronApprovalTra2 = step.tronApprovalTransaction) == null ? void 0 : _step$tronApprovalTra2.blockChain) || ''] || swap.wallets[((_step$starknetTransac2 = step.starknetTransaction) == null ? void 0 : _step$starknetTransac2.blockChain) || ''] || swap.wallets[((_step$starknetApprova2 = step.starknetApprovalTransaction) == null ? void 0 : _step$starknetApprova2.blockChain) || ''] || swap.wallets[((_step$cosmosTransacti2 = step.cosmosTransaction) == null ? void 0 : _step$cosmosTransacti2.blockChain) || ''] || swap.wallets[((_step$solanaTransacti2 = step.solanaTransaction) == null ? void 0 : _step$solanaTransacti2.blockChain) || ''] || ((_step$transferTransac2 = step.transferTransaction) != null && _step$transferTransac2.fromWalletAddress ? {
+    address: (_step$transferTransac3 = step.transferTransaction) == null ? void 0 : _step$transferTransac3.fromWalletAddress
+  } : null) || null;
+  if (result == null) throw PrettyError.WalletMissing();
+  return result.address;
+};
+function getRelatedWallet(swap, currentStep) {
+  var walletAddress = getCurrentAddressOf(swap, currentStep);
+  var walletKV = Object.keys(swap.wallets).map(function (k) {
+    return {
+      k: k,
+      v: swap.wallets[k]
+    };
+  }).find(function (_ref) {
+    var v = _ref.v;
+    return v.address === walletAddress;
+  }) || null;
+  var blockchain = (walletKV == null ? void 0 : walletKV.k) || null;
+  var wallet = (walletKV == null ? void 0 : walletKV.v) || null;
+  var walletType = wallet == null ? void 0 : wallet.walletType;
+  if (walletType === walletsShared.WalletType.UNKNOWN || wallet === null) throw PrettyError.AssertionFailed("Wallet for source " + blockchain + " not passed: walletType: " + walletType);
+  return wallet;
+}
+function getRelatedWalletOrNull(swap, currentStep) {
+  try {
+    return getRelatedWallet(swap, currentStep);
+  } catch (e) {
+    return null;
+  }
+}
+
+var SwapActionTypes;
+(function (SwapActionTypes) {
+  SwapActionTypes["START"] = "START";
+  SwapActionTypes["SCHEDULE_NEXT_STEP"] = "SCHEDULE_NEXT_STEP";
+  SwapActionTypes["CREATE_TRANSACTION"] = "CREATE_TRANSACTION";
+  SwapActionTypes["EXECUTE_TRANSACTION"] = "EXECUTE_TRANSACTION";
+  SwapActionTypes["CHECK_TRANSACTION_STATUS"] = "CHECK_TRANSACTION_STATUS";
+})(SwapActionTypes || (SwapActionTypes = {}));
+var BlockReason;
+(function (BlockReason) {
+  BlockReason["WAIT_FOR_CONNECT_WALLET"] = "waiting_for_connecting_wallet";
+  BlockReason["WAIT_FOR_NETWORK_CHANGE"] = "waiting_for_network_change";
+  BlockReason["DEPENDS_ON_OTHER_QUEUES"] = "depends_on_other_queues";
+})(BlockReason || (BlockReason = {}));
+
+var RANGO_DAPP_API_KEY = process.env.REACT_APP_API_KEY;
+var RANGO_DAPP_API_BASE_URL = process.env.REACT_APP_API_BASE_URL;
+var ERROR_MESSAGE_WAIT_FOR_WALLET = 'Waiting for connecting wallet';
+var ERROR_MESSAGE_WAIT_FOR_WALLET_DESCRIPTION_WRONG_WALLET = function ERROR_MESSAGE_WAIT_FOR_WALLET_DESCRIPTION_WRONG_WALLET(type, address) {
+  return "Please change your " + (type || 'wallet') + " account to " + (address || 'proper address');
+};
+var ERROR_MESSAGE_WAIT_FOR_WALLET_DESCRIPTION = function ERROR_MESSAGE_WAIT_FOR_WALLET_DESCRIPTION(type) {
+  return "Please connect to " + (type || 'your wallet') + " by using bellow button or top right button on page.";
+};
+var ERROR_MESSAGE_WAIT_FOR_CHANGE_NETWORK = function ERROR_MESSAGE_WAIT_FOR_CHANGE_NETWORK(network) {
+  return "Please change your network to " + network + ".";
+};
+
+function logRPCError(error, swap, currentStep, walletType) {
+  try {
+    Sentry.captureException(error, {
+      tags: {
+        requestId: swap.requestId,
+        rpc: true,
+        swapper: (currentStep == null ? void 0 : currentStep.swapperId) || '',
+        walletType: walletType || ''
+      },
+      level: 'warning'
+    });
+  } catch (e) {
+    console.log({
+      e: e
+    });
+  }
+}
+
+var httpService = /*#__PURE__*/new rangoSdk.RangoClient(RANGO_DAPP_API_KEY || '', RANGO_DAPP_API_BASE_URL);
+
+var swapClaimedBy = null;
+/**
+ *
+ * We simply use module-level variable to keep track of which queue has claimed the execution of parallel runnings.
+ *
+ */
+function claimQueue() {
+  return {
+    claimedBy: function claimedBy() {
+      var _swapClaimedBy;
+      return (_swapClaimedBy = swapClaimedBy) == null ? void 0 : _swapClaimedBy.id;
+    },
+    setClaimer: function setClaimer(queue_id) {
+      swapClaimedBy = {
+        id: queue_id
+      };
+    },
+    reset: function reset() {
+      swapClaimedBy = null;
+    }
+  };
+}
+/**
+ * Sample inputs are:
+ *  - "metamask-ETH"
+ *  - "metamask-BSC-BSC:0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+ *  - "token-pocket-BSC-BSC:0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+ * Returns "wallet and network" separately, even if the wallet is dashed inside.
+ *
+ */
+function splitWalletNetwork(input) {
+  var removedAddressInput = (input == null ? void 0 : input.split(':')[0]) || '';
+  var splittedInput = removedAddressInput.split('-');
+  var network = splittedInput[splittedInput.length - 1];
+  var walletNetwork = splittedInput.slice(0, -1);
+  if (walletNetwork[walletNetwork.length - 1] === network) {
+    walletNetwork.pop();
+  }
+  var wallet = walletNetwork.join('-');
+  return [wallet, network];
+}
+/**
+ *
+ * Returns `steps`, if it's a `running` swap.
+ * Each `PendingSwap` has a `steps` inside it, `steps` shows how many tasks should be created and run to finish the swap.
+ *
+ */
+var getCurrentStep = function getCurrentStep(swap) {
+  return swap.steps.find(function (step) {
+    return step.status !== 'failed' && step.status !== 'success';
+  }) || null;
+};
+/**
+ * When we are doing a swap, there are some common fields that will be updated together.
+ * This function helps us to update a swap status and also it will update some more fields like `extraMessageSeverity` based on the input.
+ */
+function updateSwapStatus(_ref) {
+  var getStorage = _ref.getStorage,
+    setStorage = _ref.setStorage,
+    nextStatus = _ref.nextStatus,
+    nextStepStatus = _ref.nextStepStatus,
+    message = _ref.message,
+    details = _ref.details,
+    _ref$errorCode = _ref.errorCode,
+    errorCode = _ref$errorCode === void 0 ? null : _ref$errorCode,
+    hasAlreadyProceededToSign = _ref.hasAlreadyProceededToSign;
+  var swap = getStorage().swapDetails;
+  var currentStep = getCurrentStep(swap);
+  if (!!nextStepStatus && !!currentStep) currentStep.status = nextStepStatus;
+  if (!!nextStatus) swap.status = nextStatus;
+  swap.hasAlreadyProceededToSign = hasAlreadyProceededToSign;
+  if (!!nextStatus && ['failed', 'success'].includes(nextStatus)) swap.finishTime = new Date().getTime().toString();
+  if (!!message || !!details) {
+    swap.extraMessage = message || '';
+    swap.extraMessageDetail = details || '';
+  }
+  if (!!nextStepStatus && ['failed'].includes(nextStepStatus)) {
+    var _getRelatedWalletOrNu;
+    //if user cancel the swap, we should pass relevant reason to the server.
+    var errorReason = details && details.includes('Warning') ? 'Swap canceled by user.' : details;
+    var walletType = (_getRelatedWalletOrNu = getRelatedWalletOrNull(swap, currentStep)) == null ? void 0 : _getRelatedWalletOrNu.walletType;
+    swap.extraMessageSeverity = exports.MessageSeverity.error;
+    httpService.reportFailure({
+      requestId: swap.requestId,
+      step: (currentStep == null ? void 0 : currentStep.id) || 1,
+      eventType: mapAppErrorCodesToAPIErrorCode(errorCode),
+      reason: errorReason || '',
+      data: walletType ? {
+        wallet: walletType
+      } : undefined
+    }).then()["catch"]();
+  } else if (!!nextStepStatus && ['running'].includes(nextStepStatus)) swap.extraMessageSeverity = exports.MessageSeverity.info;else if (!!nextStepStatus && ['success', 'approved'].includes(nextStepStatus)) swap.extraMessageSeverity = exports.MessageSeverity.success;else if (nextStepStatus && ['waitingForApproval'].includes(nextStepStatus)) swap.extraMessageSeverity = exports.MessageSeverity.warning;
+  if (nextStepStatus === 'running' && currentStep) currentStep.startTransactionTime = new Date().getTime();
+  setStorage(_extends({}, getStorage(), {
+    swapDetails: swap
+  }));
+  return {
+    swap: swap,
+    step: currentStep
+  };
+}
+function setStepTransactionIds(_ref2, txId, notifier, eventType, approveUrl) {
+  var getStorage = _ref2.getStorage,
+    setStorage = _ref2.setStorage;
+  var swap = getStorage().swapDetails;
+  swap.hasAlreadyProceededToSign = null;
+  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+  var currentStep = getCurrentStep(swap);
+  currentStep.executedTransactionId = txId;
+  currentStep.executedTransactionTime = new Date().getTime().toString();
+  if (!!approveUrl) currentStep.explorerUrl = [].concat(currentStep.explorerUrl || [], [{
+    url: approveUrl,
+    description: "approve"
+  }]);
+  if (eventType === 'check_tx_status') {
+    swap.extraMessage = 'Checking transaction status ...';
+    swap.extraMessageDetail = '';
+    swap.extraMessageSeverity = exports.MessageSeverity.info;
+  } else if (eventType === 'check_approve_tx_status') {
+    swap.extraMessage = 'Checking approve transaction status ...';
+    swap.extraMessageDetail = '';
+    swap.extraMessageSeverity = exports.MessageSeverity.info;
+  }
+  setStorage(_extends({}, getStorage(), {
+    swapDetails: swap
+  }));
+  if (!!eventType) notifier({
+    eventType: eventType,
+    swap: swap,
+    step: currentStep
+  });
+}
+function getSwapNotitfication(eventType, updateResult) {
+  if (updateResult.swap.hasAlreadyProceededToSign) {
+    return _extends({
+      eventType: 'transaction_expired'
+    }, updateResult);
+  } else return _extends({
+    eventType: eventType
+  }, updateResult);
+}
+/**
+ * If a swap needs a wallet to be connected,
+ * By calling this function some related fields will be updated to show a correct message and state for notfiying the user.
+ */
+function markRunningSwapAsWaitingForConnectingWallet(_ref3, reason, reasonDetail) {
+  var getStorage = _ref3.getStorage,
+    setStorage = _ref3.setStorage;
+  var swap = getStorage().swapDetails;
+  var currentStep = getCurrentStep(swap);
+  if (!currentStep) return;
+  var currentTime = new Date();
+  swap.lastNotificationTime = currentTime.getTime().toString();
+  var isAlreadyMarked = currentStep.networkStatus === exports.PendingSwapNetworkStatus.WaitingForConnectingWallet && swap.networkStatusExtraMessage === reason && swap.networkStatusExtraMessageDetail === reasonDetail;
+  if (isAlreadyMarked) {
+    return;
+  }
+  currentStep.networkStatus = exports.PendingSwapNetworkStatus.WaitingForConnectingWallet;
+  swap.networkStatusExtraMessage = reason;
+  swap.networkStatusExtraMessageDetail = reasonDetail;
+  setStorage(_extends({}, getStorage(), {
+    swapDetails: swap
+  }));
+}
+/**
+ * If a swap needs a certain network to proceed,
+ * By calling this function some related fields will be updated to show a correct message and state for notfiying the user.
+ */
+function markRunningSwapAsSwitchingNetwork(_ref4) {
+  var getStorage = _ref4.getStorage,
+    setStorage = _ref4.setStorage;
+  var swap = getStorage().swapDetails;
+  var currentStep = getCurrentStep(swap);
+  if (!currentStep) return;
+  // Generate message
+  var _getRequiredWallet = getRequiredWallet(swap),
+    type = _getRequiredWallet.type;
+  var fromBlockchain = getCurrentBlockchainOf(swap, currentStep);
+  var reason = "Change " + type + " wallet network to " + fromBlockchain;
+  var metamaskMessage = '';
+  if (type === walletsShared.WalletType.META_MASK) metamaskMessage = "(Networks -> Select '" + fromBlockchain + "' network.)";
+  var reasonDetail = "Please change your " + type + " wallet network to " + fromBlockchain + ". " + metamaskMessage;
+  var currentTime = new Date();
+  swap.lastNotificationTime = currentTime.getTime().toString();
+  currentStep.networkStatus = exports.PendingSwapNetworkStatus.WaitingForNetworkChange;
+  swap.networkStatusExtraMessage = reason;
+  swap.networkStatusExtraMessageDetail = reasonDetail;
+  setStorage(_extends({}, getStorage(), {
+    swapDetails: swap
+  }));
+  return {
+    swap: swap,
+    step: currentStep
+  };
+}
+/**
+ * We are marking the queue as it depends on other queues to be run (on Parallel mode)
+ * By calling this function some related fields will be updated to show a correct message and state for notfiying the user.
+ */
+function markRunningSwapAsDependsOnOtherQueues(_ref5) {
+  var getStorage = _ref5.getStorage,
+    setStorage = _ref5.setStorage,
+    notifier = _ref5.notifier;
+  var swap = getStorage().swapDetails;
+  var currentStep = getCurrentStep(swap);
+  if (!currentStep) return;
+  swap.networkStatusExtraMessage = '';
+  swap.networkStatusExtraMessageDetail = '';
+  currentStep.networkStatus = exports.PendingSwapNetworkStatus.WaitingForQueue;
+  notifier({
+    eventType: 'waiting_for_queue',
+    swap: swap,
+    step: currentStep
+  });
+  setStorage(_extends({}, getStorage(), {
+    swapDetails: swap
+  }));
+  return {
+    swap: swap,
+    step: currentStep
+  };
+}
+function delay(ms) {
+  return new Promise(function (res) {
+    return setTimeout(res, ms);
+  });
+}
+var isEvmTransaction = function isEvmTransaction(tx) {
+  return tx.type === rangoSdk.TransactionType.EVM;
+};
+var isCosmosTransaction = function isCosmosTransaction(tx) {
+  return tx.type === rangoSdk.TransactionType.COSMOS;
+};
+var isSolanaTransaction = function isSolanaTransaction(tx) {
+  return tx.type === rangoSdk.TransactionType.SOLANA;
+};
+var isTrasnferTransaction = function isTrasnferTransaction(tx) {
+  return tx.type === rangoSdk.TransactionType.TRANSFER;
+};
+var isStarknetTransaction = function isStarknetTransaction(tx) {
+  return tx.type === rangoSdk.TransactionType.STARKNET;
+};
+var isTronTransaction = function isTronTransaction(tx) {
+  return tx.type === rangoSdk.TransactionType.TRON;
+};
+/**
+ *
+ * To execute a swap, we are keeping the user prefrences on what wallet they are going to use for a sepecific blockchain
+ * By passing the swap and the network we are looking for, it returns the wallet name that user selected.
+ *
+ */
+var getSwapWalletType = function getSwapWalletType(swap, network) {
+  var _swap$wallets$network;
+  return (_swap$wallets$network = swap.wallets[network]) == null ? void 0 : _swap$wallets$network.walletType;
+};
+/**
+ *
+ * We are keeping the connected wallet in a specific structure (`Wallet`),
+ * By using this function we normally want to check a specific wallet is connected and exists or not.
+ *
+ */
+function isWalletNull(wallet) {
+  return wallet === null || (wallet == null ? void 0 : wallet.blockchains) === null || (wallet == null ? void 0 : wallet.blockchains.length) === 0;
+}
+/**
+ * On our implementation for `wallets` package, We keep the instance in 2 ways
+ * If it's a single chain wallet, it returns the instance directly,
+ * If it's a multichain wallet, it returns a `Map` of instances.
+ * This function will get the `ETHEREUM` instance in both types.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function getEvmProvider(providers, type) {
+  if (type && providers[type]) {
+    // we need this because provider can return an instance or a map of instances, so what you are doing here is try to detect that.
+    if (providers[type].size) return providers[type].get(walletsShared.Network.ETHEREUM);
+    return providers[type];
+  }
+  return null;
+}
+/**
+ * In a `PendingSwap`, each step needs a wallet to proceed,
+ * By using this function we can access what wallet exactly we need to run current step.
+ */
+function getRequiredWallet(swap) {
+  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+  var step = getCurrentStep(swap);
+  var bcName = getCurrentBlockchainOfOrNull(swap, step);
+  if (!bcName) {
+    return {
+      type: null,
+      network: null,
+      address: null
+    };
+  }
+  var walletType = getSwapWalletType(swap, bcName);
+  var sourceWallet = swap.wallets[bcName];
+  return {
+    type: walletType || null,
+    network: bcName,
+    address: sourceWallet ? sourceWallet.address : null
+  };
+}
+/**
+ * On EVM compatible wallets, There is one instance with different chains (like Polygon)
+ * To get the chain from instance we will use this function.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function getChainId(_x) {
+  return _getChainId.apply(this, arguments);
+}
+/**
+ * For running a swap safely, we need to make sure about the state of wallet
+ * which means the netowrk/chain of wallet should be exactly on what a transaction needs.
+ */
+function _getChainId() {
+  _getChainId = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(provider) {
+    var chainId;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          _context.next = 2;
+          return provider.request({
+            method: 'eth_chainId'
+          });
+        case 2:
+          _context.t0 = _context.sent;
+          if (_context.t0) {
+            _context.next = 5;
+            break;
+          }
+          _context.t0 = provider == null ? void 0 : provider.chainId;
+        case 5:
+          chainId = _context.t0;
+          return _context.abrupt("return", chainId);
+        case 7:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return _getChainId.apply(this, arguments);
+}
+function isNetworkMatchedForTransaction(_x2, _x3, _x4, _x5, _x6) {
+  return _isNetworkMatchedForTransaction.apply(this, arguments);
+}
+function _isNetworkMatchedForTransaction() {
+  _isNetworkMatchedForTransaction = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(swap, step, wallet, meta, providers) {
+    var fromBlockChain, sourceWallet, provider, chainId, blockChain;
+    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          if (!isWalletNull(wallet)) {
+            _context2.next = 3;
+            break;
+          }
+          console.warn('wallet object is null');
+          return _context2.abrupt("return", false);
+        case 3:
+          fromBlockChain = getCurrentBlockchainOfOrNull(swap, step);
+          if (fromBlockChain) {
+            _context2.next = 6;
+            break;
+          }
+          return _context2.abrupt("return", false);
+        case 6:
+          if (!meta.evmBasedChains.find(function (evmBlochain) {
+            return evmBlochain.name === fromBlockChain;
+          })) {
+            _context2.next = 30;
+            break;
+          }
+          _context2.prev = 7;
+          sourceWallet = swap.wallets[fromBlockChain];
+          if (!sourceWallet) {
+            _context2.next = 24;
+            break;
+          }
+          if (![walletsShared.WalletType.META_MASK, walletsShared.WalletType.BINANCE_CHAIN, walletsShared.WalletType.XDEFI, walletsShared.WalletType.WALLET_CONNECT, walletsShared.WalletType.TRUST_WALLET, walletsShared.WalletType.COIN98, walletsShared.WalletType.EXODUS, walletsShared.WalletType.OKX, walletsShared.WalletType.COINBASE, walletsShared.WalletType.TOKEN_POCKET, walletsShared.WalletType.MATH, walletsShared.WalletType.SAFEPAL, walletsShared.WalletType.COSMOSTATION, walletsShared.WalletType.CLOVER, walletsShared.WalletType.BRAVE, walletsShared.WalletType.FRONTIER, walletsShared.WalletType.KUCOIN].includes(sourceWallet.walletType)) {
+            _context2.next = 23;
+            break;
+          }
+          provider = getEvmProvider(providers, sourceWallet.walletType);
+          _context2.next = 14;
+          return getChainId(provider);
+        case 14:
+          chainId = _context2.sent;
+          if (!chainId) {
+            _context2.next = 21;
+            break;
+          }
+          blockChain = walletsShared.getBlockChainNameFromId(chainId, Object.entries(meta.blockchains).map(function (_ref6) {
+            var blockchainMeta = _ref6[1];
+            return blockchainMeta;
+          }));
+          if (!(blockChain && blockChain.toLowerCase() === fromBlockChain.toLowerCase())) {
+            _context2.next = 19;
+            break;
+          }
+          return _context2.abrupt("return", true);
+        case 19:
+          if (!(blockChain && blockChain.toLowerCase() !== fromBlockChain.toLowerCase())) {
+            _context2.next = 21;
+            break;
+          }
+          return _context2.abrupt("return", false);
+        case 21:
+          _context2.next = 24;
+          break;
+        case 23:
+          return _context2.abrupt("return", true);
+        case 24:
+          _context2.next = 29;
+          break;
+        case 26:
+          _context2.prev = 26;
+          _context2.t0 = _context2["catch"](7);
+          console.log(_context2.t0);
+        case 29:
+          return _context2.abrupt("return", false);
+        case 30:
+          return _context2.abrupt("return", true);
+        case 31:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2, null, [[7, 26]]);
+  }));
+  return _isNetworkMatchedForTransaction.apply(this, arguments);
+}
+var isTxAlreadyCreated = function isTxAlreadyCreated(swap, step) {
+  var _step$evmTransaction, _step$evmApprovalTran, _step$tronTransaction, _step$tronApprovalTra, _step$starknetTransac, _step$starknetApprova, _step$cosmosTransacti, _step$solanaTransacti, _step$transferTransac;
+  var result = swap.wallets[((_step$evmTransaction = step.evmTransaction) == null ? void 0 : _step$evmTransaction.blockChain) || ''] || swap.wallets[((_step$evmApprovalTran = step.evmApprovalTransaction) == null ? void 0 : _step$evmApprovalTran.blockChain) || ''] || swap.wallets[((_step$tronTransaction = step.tronTransaction) == null ? void 0 : _step$tronTransaction.blockChain) || ''] || swap.wallets[((_step$tronApprovalTra = step.tronApprovalTransaction) == null ? void 0 : _step$tronApprovalTra.blockChain) || ''] || swap.wallets[((_step$starknetTransac = step.starknetTransaction) == null ? void 0 : _step$starknetTransac.blockChain) || ''] || swap.wallets[((_step$starknetApprova = step.starknetApprovalTransaction) == null ? void 0 : _step$starknetApprova.blockChain) || ''] || swap.wallets[((_step$cosmosTransacti = step.cosmosTransaction) == null ? void 0 : _step$cosmosTransacti.blockChain) || ''] || swap.wallets[((_step$solanaTransacti = step.solanaTransaction) == null ? void 0 : _step$solanaTransacti.blockChain) || ''] || ((_step$transferTransac = step.transferTransaction) == null ? void 0 : _step$transferTransac.fromWalletAddress) || null;
+  return result !== null;
+};
+function resetNetworkStatus(actions) {
+  var getStorage = actions.getStorage,
+    setStorage = actions.setStorage;
+  var swap = getStorage().swapDetails;
+  var currentStep = getCurrentStep(swap);
+  if (currentStep != null && currentStep.networkStatus) {
+    currentStep.networkStatus = null;
+    setStorage(_extends({}, getStorage(), {
+      swapDetails: swap
+    }));
+  }
+}
+function updateNetworkStatus(actions, data) {
+  if (data === void 0) {
+    data = {
+      message: '',
+      details: '',
+      status: null
+    };
+  }
+  var _data = data,
+    message = _data.message,
+    details = _data.details,
+    status = _data.status;
+  var getStorage = actions.getStorage,
+    setStorage = actions.setStorage;
+  var swap = getStorage().swapDetails;
+  var currentStep = getCurrentStep(swap);
+  if (currentStep != null && currentStep.networkStatus) {
+    swap.networkStatusExtraMessage = message;
+    swap.networkStatusExtraMessageDetail = details;
+    currentStep.networkStatus = status;
+    setStorage(_extends({}, getStorage(), {
+      swapDetails: swap
+    }));
+  }
+}
+/**
+ * Event handler for blocked tasks.
+ * If a transcation execution is manually blocked (like for parallel or waiting for wallet),
+ * This function will be called by queue manager using `queue definition`.
+ *
+ * It checks if the required wallet is connected, unblock the queue to be run.
+ */
+function onBlockForConnectWallet(event, meta) {
+  var context = meta.context,
+    queue = meta.queue;
+  var swap = queue.getStorage().swapDetails;
+  var _isRequiredWalletConn = isRequiredWalletConnected(swap, context.state),
+    ok = _isRequiredWalletConn.ok,
+    reason = _isRequiredWalletConn.reason;
+  if (!ok) {
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    var currentStep = getCurrentStep(swap);
+    context.notifier({
+      eventType: reason === 'account_miss_match' ? 'waiting_for_change_wallet_account' : 'waiting_for_connecting_wallet',
+      swap: swap,
+      step: currentStep
+    });
+    markRunningSwapAsWaitingForConnectingWallet({
+      getStorage: queue.getStorage.bind(queue),
+      setStorage: queue.setStorage.bind(queue)
+    }, ERROR_MESSAGE_WAIT_FOR_WALLET, event.reason.description);
+    return;
+  }
+  queue.unblock();
+}
+/**
+ * Event handler for blocked tasks.
+ * If a transcation execution is manually blocked (like for parallel or waiting for walle),
+ * This function will be called by queue manager using `queue definition`.
+ *
+ * It checks if the required network is connected, unblock the queue to be run.
+ * Note: it automatically try to switch the network if its `provider` supports.
+ */
+function onBlockForChangeNetwork(_event, meta) {
+  var context = meta.context,
+    queue = meta.queue;
+  var swap = queue.getStorage().swapDetails;
+  var currentStep = getCurrentStep(swap);
+  if (!currentStep || swap.status !== 'running') return;
+  var result = markRunningSwapAsSwitchingNetwork({
+    getStorage: queue.getStorage.bind(queue),
+    setStorage: queue.setStorage.bind(queue)
+  });
+  if (result) {
+    context.notifier({
+      eventType: 'waiting_for_network_change',
+      swap: result.swap,
+      step: result.step
+    });
+  }
+  // Try to auto switch
+  var _getRequiredWallet2 = getRequiredWallet(swap),
+    type = _getRequiredWallet2.type,
+    network = _getRequiredWallet2.network;
+  if (!!type && !!network) {
+    var _result = context.switchNetwork(type, network);
+    if (_result) {
+      _result.then(function () {
+        queue.unblock();
+      });
+    }
+  }
+}
+/**
+ * Event handler for blocked tasks. (Parallel mode)
+ * If a transcation execution flow is manually blocked (like for parallel or waiting for walle),
+ * This function will be called by queue manager using `queue definition`.
+ *
+ * It checks the blocked tasks, if there is no active `claimed` queue, try to give it to the best candidate.
+ */
+function onDependsOnOtherQueues(_event, meta) {
+  var getBlockedTasks = meta.getBlockedTasks,
+    forceExecute = meta.forceExecute,
+    queue = meta.queue,
+    manager = meta.manager,
+    context = meta.context;
+  var _claimQueue = claimQueue(),
+    setClaimer = _claimQueue.setClaimer,
+    claimedBy = _claimQueue.claimedBy,
+    reset = _claimQueue.reset;
+  // We only needs those blocked tasks that have DEPENDS_ON_OTHER_QUEUES reason.
+  var blockedTasks = getBlockedTasks().filter(function (task) {
+    return task.reason.reason === BlockReason.DEPENDS_ON_OTHER_QUEUES;
+  });
+  if (blockedTasks.length === 0) {
+    return;
+  }
+  var claimerId = claimedBy();
+  var isClaimedByAnyQueue = !!claimerId;
+  // Check if any queue `claimed` before, if yes, we don't should do anything.
+  if (isClaimedByAnyQueue) {
+    // We need to keep the latest swap messages
+    markRunningSwapAsDependsOnOtherQueues({
+      getStorage: queue.getStorage.bind(queue),
+      setStorage: queue.setStorage.bind(queue),
+      notifier: context.notifier
+    });
+    return;
+  }
+  // Prioritize current queue to be run first.
+  var task = blockedTasks.find(function (task) {
+    return task.queue_id === meta.queue_id;
+  });
+  // If current task isn't available anymore, fallback to first blocked task.
+  if (!task) {
+    var firstBlockedTask = blockedTasks[0];
+    task = firstBlockedTask;
+  }
+  setClaimer(task.queue_id);
+  var claimedStorage = task.storage.get();
+  var _getRequiredWallet3 = getRequiredWallet(claimedStorage.swapDetails),
+    type = _getRequiredWallet3.type,
+    network = _getRequiredWallet3.network,
+    address = _getRequiredWallet3.address;
+  // Run
+  forceExecute(task.queue_id, {
+    claimedBy: claimedBy(),
+    resetClaimedBy: function resetClaimedBy() {
+      reset();
+      // TODO: Use key generator
+      retryOn(type + "-" + network + "-" + address, context.notifier, manager);
+    }
+  });
+}
+function isRequiredWalletConnected(swap, getState) {
+  var _getRequiredWallet4 = getRequiredWallet(swap),
+    type = _getRequiredWallet4.type,
+    address = _getRequiredWallet4.address;
+  if (!type || !address) {
+    return {
+      ok: false,
+      reason: 'not_connected'
+    };
+  }
+  var walletState = getState(type);
+  var accounts = walletState.accounts,
+    connected = walletState.connected;
+  var connectedAccounts = accounts || [];
+  if (!connected) return {
+    ok: false,
+    reason: 'not_connected'
+  };
+  var matched = connectedAccounts.some(function (account) {
+    var _readAccountAddress = walletsCore.readAccountAddress(account),
+      accountAddress = _readAccountAddress.address;
+    return address === accountAddress;
+  });
+  return {
+    ok: matched,
+    reason: 'account_miss_match'
+  };
+}
+function singTransaction(actions) {
+  var getStorage = actions.getStorage,
+    setStorage = actions.setStorage,
+    failed = actions.failed,
+    next = actions.next,
+    schedule = actions.schedule,
+    context = actions.context;
+  var meta = context.meta,
+    getSigners = context.getSigners,
+    notifier = context.notifier;
+  var swap = getStorage().swapDetails;
+  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+  var currentStep = getCurrentStep(swap);
+  var evmTransaction = currentStep.evmTransaction,
+    evmApprovalTransaction = currentStep.evmApprovalTransaction,
+    cosmosTransaction = currentStep.cosmosTransaction,
+    solanaTransaction = currentStep.solanaTransaction,
+    transferTransaction = currentStep.transferTransaction,
+    tronTransaction = currentStep.tronTransaction,
+    tronApprovalTransaction = currentStep.tronApprovalTransaction,
+    starknetTransaction = currentStep.starknetTransaction,
+    starknetApprovalTransaction = currentStep.starknetApprovalTransaction;
+  var sourceWallet = getRelatedWallet(swap, currentStep);
+  var walletAddress = getCurrentAddressOf(swap, currentStep);
+  var walletSigners = getSigners(sourceWallet.walletType);
+  var onFinish = function onFinish() {
+    // TODO resetClaimedBy is undefined here
+    if (actions.context.resetClaimedBy) {
+      actions.context.resetClaimedBy();
+    }
+  };
+  if (!!evmApprovalTransaction) {
+    var spenderContract = evmApprovalTransaction == null ? void 0 : evmApprovalTransaction.to;
+    if (!spenderContract) throw PrettyError.AssertionFailed('contract address is null for checking approval');
+    // Update swap status
+    var message = "waiting for approval of " + (currentStep == null ? void 0 : currentStep.fromSymbol) + " coin " + (sourceWallet.walletType === walletsShared.WalletType.WALLET_CONNECT ? 'on your mobile phone' : '');
+    var updateResult = updateSwapStatus({
+      getStorage: getStorage,
+      setStorage: setStorage,
+      nextStepStatus: 'waitingForApproval',
+      message: message,
+      details: 'Waiting for approve transaction to be mined and confirmed successfully'
+    });
+    notifier(_extends({
+      eventType: 'confirm_approve_contract'
+    }, updateResult));
+    // Execute transaction
+    walletSigners.getSigner(rangoSdk.TransactionType.EVM).signAndSendTx(evmApprovalTransaction, walletAddress, null).then(function (hash) {
+      console.debug('transaction of approval minted successfully', hash);
+      var approveUrl = getEvmApproveUrl(hash, getCurrentBlockchainOf(swap, currentStep), meta.evmBasedChains);
+      setStepTransactionIds(actions, hash, notifier, 'check_approve_tx_status', approveUrl);
+      schedule(SwapActionTypes.CHECK_TRANSACTION_STATUS);
+      next();
+      onFinish();
+    }, function (error) {
+      var _error$root, _error$root2, _error$root3;
+      if (swap.status === 'failed') return;
+      console.debug('error in approving', error);
+      var _prettifyErrorMessage = prettifyErrorMessage(error),
+        extraMessage = _prettifyErrorMessage.extraMessage,
+        extraMessageDetail = _prettifyErrorMessage.extraMessageDetail,
+        extraMessageErrorCode = _prettifyErrorMessage.extraMessageErrorCode;
+      if (error && error != null && error.root && error != null && (_error$root = error.root) != null && _error$root.message && error != null && (_error$root2 = error.root) != null && _error$root2.code && error != null && (_error$root3 = error.root) != null && _error$root3.reason) {
+        logRPCError(error.root, swap, currentStep, sourceWallet == null ? void 0 : sourceWallet.walletType);
+      }
+      var updateResult = updateSwapStatus({
+        getStorage: getStorage,
+        setStorage: setStorage,
+        nextStatus: 'failed',
+        nextStepStatus: 'failed',
+        message: extraMessage,
+        details: extraMessageDetail,
+        errorCode: extraMessageErrorCode
+      });
+      notifier(_extends({
+        eventType: 'contract_rejected'
+      }, updateResult));
+      failed();
+      onFinish();
+    });
+    return;
+  } else if (!!tronApprovalTransaction) {
+    // Update swap status
+    var _message = "waiting for approval of " + (currentStep == null ? void 0 : currentStep.fromSymbol) + " coin " + (sourceWallet.walletType === walletsShared.WalletType.WALLET_CONNECT ? 'on your mobile phone' : '');
+    var _updateResult = updateSwapStatus({
+      getStorage: getStorage,
+      setStorage: setStorage,
+      nextStepStatus: 'waitingForApproval',
+      message: _message,
+      details: 'Waiting for approve transaction to be mined and confirmed successfully'
+    });
+    notifier(_extends({
+      eventType: 'confirm_approve_contract'
+    }, _updateResult));
+    // Execute transaction
+    walletSigners.getSigner(rangoSdk.TransactionType.TRON).signAndSendTx(tronApprovalTransaction, walletAddress, null).then(function (hash) {
+      console.debug('transaction of approval minted successfully', hash);
+      var approveUrl = getTronApproveUrl(hash);
+      setStepTransactionIds(actions, hash, notifier, 'check_approve_tx_status', approveUrl);
+      schedule(SwapActionTypes.CHECK_TRANSACTION_STATUS);
+      next();
+      onFinish();
+    }, function (error) {
+      var _error$root4, _error$root5, _error$root6;
+      if (swap.status === 'failed') return;
+      console.debug('error in approving', error);
+      var _prettifyErrorMessage2 = prettifyErrorMessage(error),
+        extraMessage = _prettifyErrorMessage2.extraMessage,
+        extraMessageDetail = _prettifyErrorMessage2.extraMessageDetail,
+        extraMessageErrorCode = _prettifyErrorMessage2.extraMessageErrorCode;
+      if (error && error != null && error.root && error != null && (_error$root4 = error.root) != null && _error$root4.message && error != null && (_error$root5 = error.root) != null && _error$root5.code && error != null && (_error$root6 = error.root) != null && _error$root6.reason) {
+        logRPCError(error.root, swap, currentStep, sourceWallet == null ? void 0 : sourceWallet.walletType);
+      }
+      var updateResult = updateSwapStatus({
+        getStorage: getStorage,
+        setStorage: setStorage,
+        nextStatus: 'failed',
+        nextStepStatus: 'failed',
+        message: extraMessage,
+        details: extraMessageDetail,
+        errorCode: extraMessageErrorCode
+      });
+      notifier(_extends({
+        eventType: 'contract_rejected'
+      }, updateResult));
+      failed();
+      onFinish();
+    });
+    return;
+  } else if (!!starknetApprovalTransaction) {
+    // Update swap status
+    var _message2 = "waiting for approval of " + (currentStep == null ? void 0 : currentStep.fromSymbol) + " coin " + (sourceWallet.walletType === walletsShared.WalletType.WALLET_CONNECT ? 'on your mobile phone' : '');
+    var _updateResult2 = updateSwapStatus({
+      getStorage: getStorage,
+      setStorage: setStorage,
+      nextStepStatus: 'waitingForApproval',
+      message: _message2,
+      details: 'Waiting for approve transaction to be mined and confirmed successfully'
+    });
+    notifier(_extends({
+      eventType: 'confirm_approve_contract'
+    }, _updateResult2));
+    // Execute transaction
+    walletSigners.getSigner(rangoSdk.TransactionType.STARKNET).signAndSendTx(starknetApprovalTransaction, walletAddress, null).then(function (hash) {
+      console.debug('transaction of approval minted successfully', hash);
+      var approveUrl = getStarknetApproveUrl(hash);
+      setStepTransactionIds(actions, hash, notifier, 'check_approve_tx_status', approveUrl);
+      schedule(SwapActionTypes.CHECK_TRANSACTION_STATUS);
+      next();
+      onFinish();
+    }, function (error) {
+      var _error$root7, _error$root8, _error$root9;
+      if (swap.status === 'failed') return;
+      console.debug('error in approving', error);
+      var _prettifyErrorMessage3 = prettifyErrorMessage(error),
+        extraMessage = _prettifyErrorMessage3.extraMessage,
+        extraMessageDetail = _prettifyErrorMessage3.extraMessageDetail,
+        extraMessageErrorCode = _prettifyErrorMessage3.extraMessageErrorCode;
+      if (error && error != null && error.root && error != null && (_error$root7 = error.root) != null && _error$root7.message && error != null && (_error$root8 = error.root) != null && _error$root8.code && error != null && (_error$root9 = error.root) != null && _error$root9.reason) {
+        logRPCError(error.root, swap, currentStep, sourceWallet == null ? void 0 : sourceWallet.walletType);
+      }
+      var updateResult = updateSwapStatus({
+        getStorage: getStorage,
+        setStorage: setStorage,
+        nextStatus: 'failed',
+        nextStepStatus: 'failed',
+        message: extraMessage,
+        details: extraMessageDetail,
+        errorCode: extraMessageErrorCode
+      });
+      notifier(_extends({
+        eventType: 'contract_rejected'
+      }, updateResult));
+      failed();
+      onFinish();
+    });
+    return;
+  }
+  var hasAlreadyProceededToSign = typeof swap.hasAlreadyProceededToSign === 'boolean';
+  var nextStepStatusBasedOnHasAlreadyProceededToSign = hasAlreadyProceededToSign ? 'failed' : 'running';
+  var errorCodeBasedOnHasAlreadyProceededToSign = hasAlreadyProceededToSign ? 'TX_EXPIRED' : null;
+  var executeMessage = hasAlreadyProceededToSign ? 'Transaction is expired. Please try again' : 'executing transaction';
+  var executeDetails = "" + (sourceWallet.walletType === walletsShared.WalletType.WALLET_CONNECT ? 'Check your mobile phone' : '');
+  if (!!transferTransaction) {
+    var _updateResult3 = updateSwapStatus({
+      getStorage: getStorage,
+      setStorage: setStorage,
+      nextStepStatus: nextStepStatusBasedOnHasAlreadyProceededToSign,
+      nextStatus: nextStepStatusBasedOnHasAlreadyProceededToSign,
+      message: executeMessage,
+      details: executeDetails,
+      hasAlreadyProceededToSign: hasAlreadyProceededToSign,
+      errorCode: errorCodeBasedOnHasAlreadyProceededToSign
+    });
+    var notification = getSwapNotitfication('confirm_transfer', _updateResult3);
+    notifier(notification);
+    if (notification.eventType === 'transaction_expired') {
+      failed();
+      onFinish();
+    } else {
+      walletSigners.getSigner(rangoSdk.TransactionType.TRANSFER).signAndSendTx(transferTransaction, walletAddress, null).then(function (txId) {
+        setStepTransactionIds(actions, txId, notifier, 'check_tx_status');
+        schedule(SwapActionTypes.CHECK_TRANSACTION_STATUS);
+        next();
+        onFinish();
+      }, function (error) {
+        if (swap.status === 'failed') return;
+        var _prettifyErrorMessage4 = prettifyErrorMessage(error),
+          extraMessage = _prettifyErrorMessage4.extraMessage,
+          extraMessageDetail = _prettifyErrorMessage4.extraMessageDetail,
+          extraMessageErrorCode = _prettifyErrorMessage4.extraMessageErrorCode;
+        var updateResult = updateSwapStatus({
+          getStorage: getStorage,
+          setStorage: setStorage,
+          nextStatus: 'failed',
+          nextStepStatus: 'failed',
+          message: extraMessage,
+          details: extraMessageDetail,
+          errorCode: extraMessageErrorCode
+        });
+        notifier(_extends({
+          eventType: 'transfer_rejected'
+        }, updateResult));
+        failed();
+        onFinish();
+      });
+    }
+  } else if (!!evmTransaction) {
+    var _updateResult4 = updateSwapStatus({
+      getStorage: getStorage,
+      setStorage: setStorage,
+      nextStepStatus: nextStepStatusBasedOnHasAlreadyProceededToSign,
+      nextStatus: nextStepStatusBasedOnHasAlreadyProceededToSign,
+      message: executeMessage,
+      details: executeDetails,
+      hasAlreadyProceededToSign: hasAlreadyProceededToSign,
+      errorCode: errorCodeBasedOnHasAlreadyProceededToSign
+    });
+    var _notification = getSwapNotitfication('calling_smart_contract', _updateResult4);
+    notifier(_notification);
+    if (_notification.eventType === 'transaction_expired') {
+      failed();
+      onFinish();
+    } else {
+      walletSigners.getSigner(rangoSdk.TransactionType.EVM).signAndSendTx(evmTransaction, walletAddress, null).then(function (id) {
+        setStepTransactionIds(actions, id, notifier, 'check_tx_status');
+        schedule(SwapActionTypes.CHECK_TRANSACTION_STATUS);
+        next();
+        onFinish();
+      }, function (error) {
+        var _error$root10, _error$root11, _error$root12;
+        if (swap.status === 'failed') return;
+        var _prettifyErrorMessage5 = prettifyErrorMessage(error),
+          extraMessage = _prettifyErrorMessage5.extraMessage,
+          extraMessageDetail = _prettifyErrorMessage5.extraMessageDetail,
+          extraMessageErrorCode = _prettifyErrorMessage5.extraMessageErrorCode;
+        if (error && error != null && error.root && error != null && (_error$root10 = error.root) != null && _error$root10.message && error != null && (_error$root11 = error.root) != null && _error$root11.code && error != null && (_error$root12 = error.root) != null && _error$root12.reason) {
+          logRPCError(error.root, swap, currentStep, sourceWallet == null ? void 0 : sourceWallet.walletType);
+        }
+        var updateResult = updateSwapStatus({
+          getStorage: getStorage,
+          setStorage: setStorage,
+          nextStatus: 'failed',
+          nextStepStatus: 'failed',
+          message: extraMessage,
+          details: extraMessageDetail,
+          errorCode: extraMessageErrorCode
+        });
+        notifier(_extends({
+          eventType: 'smart_contract_call_failed'
+        }, updateResult));
+        failed();
+        onFinish();
+      });
+    }
+  } else if (!!cosmosTransaction) {
+    var _updateResult5 = updateSwapStatus({
+      getStorage: getStorage,
+      setStorage: setStorage,
+      nextStepStatus: nextStepStatusBasedOnHasAlreadyProceededToSign,
+      nextStatus: nextStepStatusBasedOnHasAlreadyProceededToSign,
+      message: executeMessage,
+      details: executeDetails,
+      hasAlreadyProceededToSign: hasAlreadyProceededToSign,
+      errorCode: errorCodeBasedOnHasAlreadyProceededToSign
+    });
+    var _notification2 = getSwapNotitfication('calling_smart_contract', _updateResult5);
+    notifier(_notification2);
+    if (_notification2.eventType === 'transaction_expired') {
+      failed();
+      onFinish();
+    } else {
+      // If keplr wallet is executing contracts on terra, throw error. keplr doesn't support transfer or execute contracts. only IBC messages are supported
+      if (((currentStep == null ? void 0 : currentStep.swapperId.toString()) === 'TerraSwap' || (currentStep == null ? void 0 : currentStep.swapperId.toString()) === 'ThorChain' && (currentStep == null ? void 0 : currentStep.fromBlockchain) === walletsShared.Network.TERRA || (currentStep == null ? void 0 : currentStep.swapperId.toString()) === 'Terra Bridge' && currentStep.fromBlockchain === walletsShared.Network.TERRA) &&
+      // here we must allow ibc on terrastatus
+      sourceWallet.walletType === walletsShared.WalletType.KEPLR) {
+        var _prettifyErrorMessage6 = prettifyErrorMessage('Keplr only supports IBC Transactions on Terra. ' + 'Using Terra Bridge, TerraSwap and THORChain is not possible with Keplr. Please use TerraStation or Leap wallet'),
+          extraMessage = _prettifyErrorMessage6.extraMessage,
+          extraMessageDetail = _prettifyErrorMessage6.extraMessageDetail,
+          extraMessageErrorCode = _prettifyErrorMessage6.extraMessageErrorCode;
+        var _updateResult6 = updateSwapStatus({
+          getStorage: getStorage,
+          setStorage: setStorage,
+          nextStatus: 'failed',
+          nextStepStatus: 'failed',
+          message: extraMessage,
+          details: extraMessageDetail,
+          errorCode: extraMessageErrorCode
+        });
+        notifier(_extends({
+          eventType: 'smart_contract_call_failed'
+        }, _updateResult6));
+        failed();
+        onFinish();
+        return;
+      }
+      walletSigners.getSigner(rangoSdk.TransactionType.COSMOS).signAndSendTx(cosmosTransaction, walletAddress, null).then(
+      // todo
+      function (id) {
+        setStepTransactionIds(actions, id, notifier, 'check_tx_status');
+        schedule(SwapActionTypes.CHECK_TRANSACTION_STATUS);
+        next();
+        onFinish();
+      }, function (error) {
+        if (swap.status === 'failed') return;
+        var _prettifyErrorMessage7 = prettifyErrorMessage(error),
+          extraMessage = _prettifyErrorMessage7.extraMessage,
+          extraMessageDetail = _prettifyErrorMessage7.extraMessageDetail,
+          extraMessageErrorCode = _prettifyErrorMessage7.extraMessageErrorCode;
+        var updateResult = updateSwapStatus({
+          getStorage: getStorage,
+          setStorage: setStorage,
+          nextStatus: 'failed',
+          nextStepStatus: 'failed',
+          message: extraMessage,
+          details: extraMessageDetail,
+          errorCode: extraMessageErrorCode
+        });
+        notifier(_extends({
+          eventType: 'smart_contract_call_failed'
+        }, updateResult));
+        failed();
+        onFinish();
+      });
+    }
+  } else if (!!solanaTransaction) {
+    var _updateResult7 = updateSwapStatus({
+      getStorage: getStorage,
+      setStorage: setStorage,
+      nextStepStatus: nextStepStatusBasedOnHasAlreadyProceededToSign,
+      nextStatus: nextStepStatusBasedOnHasAlreadyProceededToSign,
+      message: executeMessage,
+      details: executeDetails,
+      hasAlreadyProceededToSign: hasAlreadyProceededToSign,
+      errorCode: errorCodeBasedOnHasAlreadyProceededToSign
+    });
+    var _notification3 = getSwapNotitfication('calling_smart_contract', _updateResult7);
+    notifier(_notification3);
+    if (_notification3.eventType === 'transaction_expired') {
+      failed();
+      onFinish();
+    } else {
+      var tx = solanaTransaction;
+      walletSigners.getSigner(rangoSdk.TransactionType.SOLANA).signAndSendTx(tx, walletAddress, null).then(function (txId) {
+        setStepTransactionIds(actions, txId, notifier, 'check_tx_status');
+        schedule(SwapActionTypes.CHECK_TRANSACTION_STATUS);
+        next();
+        onFinish();
+      }, function (error) {
+        if (swap.status === 'failed') return;
+        var _prettifyErrorMessage8 = prettifyErrorMessage(error),
+          extraMessage = _prettifyErrorMessage8.extraMessage,
+          extraMessageDetail = _prettifyErrorMessage8.extraMessageDetail,
+          extraMessageErrorCode = _prettifyErrorMessage8.extraMessageErrorCode;
+        var updateResult = updateSwapStatus({
+          getStorage: getStorage,
+          setStorage: setStorage,
+          nextStatus: 'failed',
+          nextStepStatus: 'failed',
+          message: extraMessage,
+          details: extraMessageDetail,
+          errorCode: extraMessageErrorCode
+        });
+        notifier(_extends({
+          eventType: 'smart_contract_call_failed'
+        }, updateResult));
+        failed();
+        onFinish();
+      });
+    }
+  } else if (!!tronTransaction) {
+    var _updateResult8 = updateSwapStatus({
+      getStorage: getStorage,
+      setStorage: setStorage,
+      nextStepStatus: nextStepStatusBasedOnHasAlreadyProceededToSign,
+      nextStatus: nextStepStatusBasedOnHasAlreadyProceededToSign,
+      message: executeMessage,
+      details: executeDetails,
+      hasAlreadyProceededToSign: hasAlreadyProceededToSign,
+      errorCode: errorCodeBasedOnHasAlreadyProceededToSign
+    });
+    var _notification4 = getSwapNotitfication('calling_smart_contract', _updateResult8);
+    notifier(_notification4);
+    if (_notification4.eventType === 'transaction_expired') {
+      failed();
+      onFinish();
+    } else {
+      walletSigners.getSigner(rangoSdk.TransactionType.TRON).signAndSendTx(tronTransaction, walletAddress, null).then(function (id) {
+        setStepTransactionIds(actions, id, notifier, 'check_tx_status');
+        schedule(SwapActionTypes.CHECK_TRANSACTION_STATUS);
+        next();
+        onFinish();
+      }, function (error) {
+        var _error$root13, _error$root14, _error$root15;
+        if (swap.status === 'failed') return;
+        var _prettifyErrorMessage9 = prettifyErrorMessage(error),
+          extraMessage = _prettifyErrorMessage9.extraMessage,
+          extraMessageDetail = _prettifyErrorMessage9.extraMessageDetail,
+          extraMessageErrorCode = _prettifyErrorMessage9.extraMessageErrorCode;
+        if (error && error != null && error.root && error != null && (_error$root13 = error.root) != null && _error$root13.message && error != null && (_error$root14 = error.root) != null && _error$root14.code && error != null && (_error$root15 = error.root) != null && _error$root15.reason) {
+          logRPCError(error.root, swap, currentStep, sourceWallet == null ? void 0 : sourceWallet.walletType);
+        }
+        var updateResult = updateSwapStatus({
+          getStorage: getStorage,
+          setStorage: setStorage,
+          nextStatus: 'failed',
+          nextStepStatus: 'failed',
+          message: extraMessage,
+          details: extraMessageDetail,
+          errorCode: extraMessageErrorCode
+        });
+        notifier(_extends({
+          eventType: 'smart_contract_call_failed'
+        }, updateResult));
+        failed();
+        onFinish();
+      });
+    }
+  } else if (!!starknetTransaction) {
+    var _updateResult9 = updateSwapStatus({
+      getStorage: getStorage,
+      setStorage: setStorage,
+      nextStepStatus: nextStepStatusBasedOnHasAlreadyProceededToSign,
+      nextStatus: nextStepStatusBasedOnHasAlreadyProceededToSign,
+      message: executeMessage,
+      details: executeDetails,
+      hasAlreadyProceededToSign: hasAlreadyProceededToSign,
+      errorCode: errorCodeBasedOnHasAlreadyProceededToSign
+    });
+    var _notification5 = getSwapNotitfication('calling_smart_contract', _updateResult9);
+    notifier(_notification5);
+    if (_notification5.eventType === 'transaction_expired') {
+      failed();
+      onFinish();
+    } else {
+      walletSigners.getSigner(rangoSdk.TransactionType.STARKNET).signAndSendTx(starknetTransaction, walletAddress, null).then(function (id) {
+        setStepTransactionIds(actions, id, notifier, 'check_tx_status');
+        schedule(SwapActionTypes.CHECK_TRANSACTION_STATUS);
+        next();
+        onFinish();
+      }, function (error) {
+        var _error$root16, _error$root17, _error$root18;
+        if (swap.status === 'failed') return;
+        var _prettifyErrorMessage10 = prettifyErrorMessage(error),
+          extraMessage = _prettifyErrorMessage10.extraMessage,
+          extraMessageDetail = _prettifyErrorMessage10.extraMessageDetail,
+          extraMessageErrorCode = _prettifyErrorMessage10.extraMessageErrorCode;
+        if (error && error != null && error.root && error != null && (_error$root16 = error.root) != null && _error$root16.message && error != null && (_error$root17 = error.root) != null && _error$root17.code && error != null && (_error$root18 = error.root) != null && _error$root18.reason) {
+          logRPCError(error.root, swap, currentStep, sourceWallet == null ? void 0 : sourceWallet.walletType);
+        }
+        var updateResult = updateSwapStatus({
+          getStorage: getStorage,
+          setStorage: setStorage,
+          nextStatus: 'failed',
+          nextStepStatus: 'failed',
+          message: extraMessage,
+          details: extraMessageDetail,
+          errorCode: extraMessageErrorCode
+        });
+        notifier(_extends({
+          eventType: 'smart_contract_call_failed'
+        }, updateResult));
+        failed();
+        onFinish();
+      });
+    }
+  }
+}
+function checkWaitingForConnectWalletChange(params) {
+  var wallet_network = params.wallet_network,
+    evmChains = params.evmChains,
+    manager = params.manager;
+  var _splitWalletNetwork = splitWalletNetwork(wallet_network),
+    wallet = _splitWalletNetwork[0],
+    network = _splitWalletNetwork[1];
+  // We only need change network for EVM chains.
+  if (!evmChains.some(function (chain) {
+    return chain.name == network;
+  })) return;
+  manager == null ? void 0 : manager.getAll().forEach(function (q) {
+    var queueStorage = q.list.getStorage();
+    var swap = queueStorage == null ? void 0 : queueStorage.swapDetails;
+    if (swap && swap.status === 'running') {
+      var currentStep = getCurrentStep(swap);
+      if (currentStep) {
+        var _queueStorage$swapDet;
+        var currentStepRequiredWallet = queueStorage == null ? void 0 : (_queueStorage$swapDet = queueStorage.swapDetails.wallets[currentStep.fromBlockchain]) == null ? void 0 : _queueStorage$swapDet.walletType;
+        var hasWaitingForConnect = Object.keys(q.list.state.tasks).some(function (taskId) {
+          var _task$blockedFor;
+          var task = q.list.state.tasks[taskId];
+          return task.status === queueManagerCore.Status.BLOCKED &&
+          // TODO double check later
+          [BlockReason.WAIT_FOR_CONNECT_WALLET].includes((_task$blockedFor = task.blockedFor) == null ? void 0 : _task$blockedFor.reason);
+        });
+        if (currentStepRequiredWallet === wallet && hasWaitingForConnect && getCurrentBlockchainOfOrNull(swap, currentStep) != network) {
+          var queueInstance = q.list;
+          var _getRequiredWallet5 = getRequiredWallet(swap),
+            type = _getRequiredWallet5.type;
+          var description = ERROR_MESSAGE_WAIT_FOR_CHANGE_NETWORK(type);
+          q.list.block({
+            reason: {
+              reason: BlockReason.WAIT_FOR_NETWORK_CHANGE,
+              description: description
+            },
+            silent: true
+          });
+          var result = markRunningSwapAsSwitchingNetwork({
+            getStorage: queueInstance.getStorage.bind(queueInstance),
+            setStorage: queueInstance.setStorage.bind(queueInstance)
+          });
+          if (result) {
+            params == null ? void 0 : params.notifier({
+              eventType: 'waiting_for_network_change',
+              swap: result.swap,
+              step: result.step
+            });
+          }
+        }
+      }
+    }
+  });
+}
+function checkWaitingForNetworkChange(manager) {
+  manager == null ? void 0 : manager.getAll().forEach(function (q) {
+    var hasWaitingForNetwork = Object.keys(q.list.state.tasks).some(function (taskId) {
+      var _task$blockedFor2;
+      var task = q.list.state.tasks[taskId];
+      return task.status === queueManagerCore.Status.BLOCKED && [BlockReason.WAIT_FOR_NETWORK_CHANGE, BlockReason.DEPENDS_ON_OTHER_QUEUES].includes((_task$blockedFor2 = task.blockedFor) == null ? void 0 : _task$blockedFor2.reason);
+    });
+    if (hasWaitingForNetwork) {
+      var _q$list$getStorage;
+      var swap = (_q$list$getStorage = q.list.getStorage()) == null ? void 0 : _q$list$getStorage.swapDetails;
+      if (swap.status === 'running') {
+        var _getRequiredWallet6 = getRequiredWallet(swap),
+          type = _getRequiredWallet6.type;
+        var description = ERROR_MESSAGE_WAIT_FOR_WALLET_DESCRIPTION(type);
+        // Change the block reason to waiting for connecting wallet
+        q.list.block({
+          reason: {
+            reason: BlockReason.WAIT_FOR_CONNECT_WALLET,
+            description: description
+          }
+        });
+      }
+    }
+  });
+}
+/**
+ * Get list of all running swaps
+ *
+ * @param manager
+ * @returns list of pending swaps
+ */
+function getRunningSwaps(manager) {
+  var queues = (manager == null ? void 0 : manager.getAll()) || new Map();
+  var result = [];
+  queues.forEach(function (q) {
+    // retry only on affected queues
+    var queueStorage = q.list.getStorage();
+    var swap = queueStorage == null ? void 0 : queueStorage.swapDetails;
+    if (!swap || swap.status !== 'running') return;
+    result.push(swap);
+  });
+  return result;
+}
+/**
+ *
+ * Trying to reset notifications for pending swaps to correct message on page load.
+ * We could remove this after supporting auto connect for wallets.
+ *
+ * @param swaps
+ * @param notifier
+ * @returns
+ */
+function resetRunningSwapNotifsOnPageLoad(runningSwaps, notifier) {
+  runningSwaps.forEach(function (swap) {
+    var currentStep = getCurrentStep(swap);
+    var eventType;
+    if ((currentStep == null ? void 0 : currentStep.networkStatus) === exports.PendingSwapNetworkStatus.WaitingForQueue) eventType = 'waiting_for_queue';else if ((swap == null ? void 0 : swap.status) === 'running') {
+      eventType = 'waiting_for_connecting_wallet';
+    }
+    if (!!eventType && !!notifier) {
+      notifier({
+        eventType: eventType,
+        swap: swap,
+        step: currentStep
+      });
+    }
+  });
+}
+/**
+ *
+ * Try to run blocked tasks by wallet and network name.
+ * Goes through queues and extract blocked queues with matched wallet.
+ * If found any blocked tasks with same wallet and network, runs them.
+ * If not, runs only blocked tasks with matched wallet.
+ *
+ * @param wallet_network a string includes `wallet` type and `network` type.
+ * @param manager
+ * @returns
+ */
+function retryOn(wallet_network, notifier, manager, options) {
+  var _finalQueueToBeRun;
+  if (options === void 0) {
+    options = {
+      fallbackToOnlyWallet: true
+    };
+  }
+  var _splitWalletNetwork2 = splitWalletNetwork(wallet_network),
+    wallet = _splitWalletNetwork2[0],
+    network = _splitWalletNetwork2[1];
+  if (!wallet || !network) {
+    return;
+  }
+  var walletAndNetworkMatched = [];
+  var onlyWalletMatched = [];
+  manager == null ? void 0 : manager.getAll().forEach(function (q) {
+    // retry only on affected queues
+    if (q.status === queueManagerCore.Status.BLOCKED) {
+      var queueStorage = q.list.getStorage();
+      var swap = queueStorage == null ? void 0 : queueStorage.swapDetails;
+      if (swap && swap.status === 'running') {
+        var currentStep = getCurrentStep(swap);
+        if (currentStep) {
+          var _queueStorage$swapDet2, _queueStorage$swapDet3;
+          if (getCurrentBlockchainOfOrNull(swap, currentStep) == network && (queueStorage == null ? void 0 : (_queueStorage$swapDet2 = queueStorage.swapDetails.wallets[network]) == null ? void 0 : _queueStorage$swapDet2.walletType) === wallet) {
+            walletAndNetworkMatched.push(q.list);
+          } else if ((queueStorage == null ? void 0 : (_queueStorage$swapDet3 = queueStorage.swapDetails.wallets[currentStep.fromBlockchain]) == null ? void 0 : _queueStorage$swapDet3.walletType) === wallet) {
+            onlyWalletMatched.push(q.list);
+          }
+        }
+      }
+    }
+  });
+  var finalQueueToBeRun = undefined;
+  if (walletAndNetworkMatched.length > 0) {
+    finalQueueToBeRun = walletAndNetworkMatched[0];
+    if (walletAndNetworkMatched.length > 1) {
+      for (var i = 1; i < walletAndNetworkMatched.length; i++) {
+        var currentQueue = walletAndNetworkMatched[i];
+        markRunningSwapAsDependsOnOtherQueues({
+          getStorage: currentQueue.getStorage.bind(currentQueue),
+          setStorage: currentQueue.setStorage.bind(currentQueue),
+          notifier: notifier
+        });
+      }
+    }
+  } else if (onlyWalletMatched.length > 0 && options.fallbackToOnlyWallet) {
+    finalQueueToBeRun = onlyWalletMatched[0];
+  }
+  (_finalQueueToBeRun = finalQueueToBeRun) == null ? void 0 : _finalQueueToBeRun.checkBlock();
+}
+/*
+  For avoiding conflict by making too many requests to wallet, we need to make sure
+  We only run one request at a time (In parallel mode).
+  */
+function isNeedBlockQueueForParallel(step) {
+  return !!step.evmTransaction || !!step.evmApprovalTransaction || !!step.cosmosTransaction;
+}
+/*
+Create transaction endpoint doesn't return error code on http status code,
+For backward compatibilty with server and sdk, we use this wrapper to reject the promise.
+*/
+function throwOnOK(_x7) {
+  return _throwOnOK.apply(this, arguments);
+}
+function _throwOnOK() {
+  _throwOnOK = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(rawResponse) {
+    var responseBody;
+    return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+      while (1) switch (_context3.prev = _context3.next) {
+        case 0:
+          _context3.prev = 0;
+          _context3.next = 3;
+          return rawResponse;
+        case 3:
+          responseBody = _context3.sent;
+          if (!(!responseBody.ok || !responseBody.transaction)) {
+            _context3.next = 6;
+            break;
+          }
+          throw PrettyError.CreateTransaction(responseBody.error || 'bad response from create tx endpoint');
+        case 6:
+          return _context3.abrupt("return", responseBody);
+        case 9:
+          _context3.prev = 9;
+          _context3.t0 = _context3["catch"](0);
+          throw _context3.t0;
+        case 12:
+        case "end":
+          return _context3.stop();
+      }
+    }, _callee3, null, [[0, 9]]);
+  }));
+  return _throwOnOK.apply(this, arguments);
+}
+function cancelSwap(swap) {
+  swap.actions.cancel();
+  return updateSwapStatus({
+    getStorage: swap.actions.getStorage,
+    setStorage: swap.actions.setStorage,
+    message: 'Swap canceled by user.',
+    details: "Warning: If you've already signed and sent a transaction, it won't be affected, but next swap steps will not be executed.",
+    nextStatus: 'failed',
+    nextStepStatus: 'failed',
+    errorCode: 'USER_CANCEL'
+  });
+}
+
+var INTERVAL_FOR_CHECK = 3000;
+/**
+ * Subscribe to status of swap transaction by checking from server periodically.
+ * After getting the status, notify the user and schedule `SCHEDULE_NEXT_STEP`.
+ */
+function checkTransactionStatus(_x) {
+  return _checkTransactionStatus.apply(this, arguments);
+}
+/**
+ * Subscribe to status of approval transaction by checking from server periodically.
+ * After getting the status, notify the user and schedule `SCHEDULE_NEXT_STEP`.
+ */
+function _checkTransactionStatus() {
+  _checkTransactionStatus = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(_ref) {
+    var _status, _status2, _status3, _status4, _status5, _status6, _status7, _status8, _status9, _status10;
+    var getStorage, setStorage, next, schedule, retry, context, swap, currentStep, txId, status, outputAmount, prevOutputAmount, newTransaction, nextStep;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          getStorage = _ref.getStorage, setStorage = _ref.setStorage, next = _ref.next, schedule = _ref.schedule, retry = _ref.retry, context = _ref.context;
+          swap = getStorage().swapDetails; // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+          currentStep = getCurrentStep(swap);
+          txId = currentStep.executedTransactionId;
+          status = null;
+          _context.prev = 5;
+          _context.next = 8;
+          return httpService.checkStatus({
+            requestId: swap.requestId,
+            txId: txId,
+            step: currentStep.id
+          });
+        case 8:
+          status = _context.sent;
+          _context.next = 17;
+          break;
+        case 11:
+          _context.prev = 11;
+          _context.t0 = _context["catch"](5);
+          _context.next = 15;
+          return delay(INTERVAL_FOR_CHECK);
+        case 15:
+          retry();
+          return _context.abrupt("return");
+        case 17:
+          outputAmount = ((_status = status) == null ? void 0 : _status.outputAmount) || (!!currentStep.outputAmount ? currentStep.outputAmount : null);
+          prevOutputAmount = currentStep.outputAmount;
+          swap.extraMessage = ((_status2 = status) == null ? void 0 : _status2.extraMessage) || swap.extraMessage;
+          swap.extraMessageSeverity = exports.MessageSeverity.info;
+          swap.extraMessageDetail = '';
+          currentStep.status = ((_status3 = status) == null ? void 0 : _status3.status) || currentStep.status;
+          currentStep.diagnosisUrl = ((_status4 = status) == null ? void 0 : _status4.diagnosisUrl) || currentStep.diagnosisUrl || null;
+          currentStep.outputAmount = outputAmount || currentStep.outputAmount;
+          currentStep.explorerUrl = ((_status5 = status) == null ? void 0 : _status5.explorerUrl) || currentStep.explorerUrl;
+          currentStep.internalSteps = ((_status6 = status) == null ? void 0 : _status6.steps) || null;
+          newTransaction = (_status7 = status) == null ? void 0 : _status7.newTx;
+          if (!!newTransaction) {
+            currentStep.status = 'created';
+            currentStep.executedTransactionId = null;
+            currentStep.executedTransactionTime = null;
+            currentStep.transferTransaction = null;
+            currentStep.cosmosTransaction = null;
+            currentStep.evmTransaction = null;
+            currentStep.solanaTransaction = null;
+            currentStep.evmApprovalTransaction = null;
+            currentStep.starknetApprovalTransaction = null;
+            currentStep.starknetTransaction = null;
+            currentStep.tronApprovalTransaction = null;
+            currentStep.tronTransaction = null;
+            if (isEvmTransaction(newTransaction)) {
+              if (newTransaction.isApprovalTx) currentStep.evmApprovalTransaction = newTransaction;else currentStep.evmTransaction = newTransaction;
+            } else if (isCosmosTransaction(newTransaction)) {
+              currentStep.cosmosTransaction = newTransaction;
+            } else if (isSolanaTransaction(newTransaction)) {
+              currentStep.solanaTransaction = newTransaction;
+            } else if (isTrasnferTransaction(newTransaction)) {
+              currentStep.transferTransaction = newTransaction;
+            } else if (isStarknetTransaction(newTransaction)) {
+              if (newTransaction.isApprovalTx) currentStep.starknetApprovalTransaction = newTransaction;else currentStep.starknetTransaction = newTransaction;
+            } else if (isTronTransaction(newTransaction)) {
+              if (newTransaction.isApprovalTx) currentStep.tronApprovalTransaction = newTransaction;else currentStep.tronTransaction = newTransaction;
+            }
+          }
+          if (prevOutputAmount === null && outputAmount !== null) context.notifier({
+            eventType: 'step_completed_with_output',
+            swap: swap,
+            step: currentStep
+          });else if (prevOutputAmount === null && outputAmount === null) {
+            // it is needed to set notification after reloading the page
+            context.notifier({
+              eventType: 'check_tx_status',
+              swap: swap,
+              step: currentStep
+            });
+          }
+          if (currentStep.status === 'success') {
+            nextStep = getNextStep(swap, currentStep);
+            swap.extraMessageDetail = '';
+            swap.extraMessage = !!nextStep ? "starting next step: " + nextStep.swapperId + ": " + nextStep.fromBlockchain + " -> " + nextStep.toBlockchain : '';
+          } else if (currentStep.status === 'failed') {
+            swap.extraMessage = 'Transaction failed in blockchain';
+            swap.extraMessageSeverity = exports.MessageSeverity.error;
+            swap.extraMessageDetail = '';
+          }
+          // Sync data with storage
+          setStorage(_extends({}, getStorage(), {
+            swapDetails: swap
+          }));
+          if (!(((_status8 = status) == null ? void 0 : _status8.status) === 'failed' || ((_status9 = status) == null ? void 0 : _status9.status) === 'success' || ((_status10 = status) == null ? void 0 : _status10.status) === 'running' && !!status.newTx)) {
+            _context.next = 37;
+            break;
+          }
+          schedule(SwapActionTypes.SCHEDULE_NEXT_STEP);
+          next();
+          _context.next = 40;
+          break;
+        case 37:
+          _context.next = 39;
+          return delay(INTERVAL_FOR_CHECK);
+        case 39:
+          retry();
+        case 40:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee, null, [[5, 11]]);
+  }));
+  return _checkTransactionStatus.apply(this, arguments);
+}
+function checkApprovalStatus(_x2) {
+  return _checkApprovalStatus.apply(this, arguments);
+}
+/**
+ *
+ * For doing a swap the user needs to accept a `contract` so it can use the user balance.
+ * There is two types of check status:
+ *  1. Checking approval transaction (Give permission to a contract)
+ *  2. Checking swap transaction.
+ *
+ */
+function _checkApprovalStatus() {
+  _checkApprovalStatus = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(_ref2) {
+    var getStorage, setStorage, next, schedule, retry, failed, context, swap, currentStep, isApproved, response, updateResult;
+    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          getStorage = _ref2.getStorage, setStorage = _ref2.setStorage, next = _ref2.next, schedule = _ref2.schedule, retry = _ref2.retry, failed = _ref2.failed, context = _ref2.context;
+          swap = getStorage().swapDetails; // double check it after fixing parallel
+          // const onFinish = () => {
+          //   // TODO resetClaimedBy is undefined here
+          //   if (context.resetClaimedBy) {
+          //     context.resetClaimedBy();
+          //   }
+          // };
+          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+          currentStep = getCurrentStep(swap);
+          isApproved = false;
+          _context2.prev = 4;
+          _context2.next = 7;
+          return httpService.checkApproval(swap.requestId, currentStep.executedTransactionId || '');
+        case 7:
+          response = _context2.sent;
+          isApproved = response.isApproved;
+          if (!isApproved && response.txStatus === 'failed') {
+            // approve transaction failed on
+            // we should fail the whole swap
+            updateResult = updateSwapStatus({
+              getStorage: getStorage,
+              setStorage: setStorage,
+              nextStatus: 'failed',
+              nextStepStatus: 'failed',
+              errorCode: 'SEND_TX_FAILED',
+              message: 'Approve transaction failed',
+              details: 'Smart contract approval failed in blockchain.'
+            });
+            context.notifier(_extends({
+              eventType: 'smart_contract_call_failed'
+            }, updateResult));
+            failed();
+            // onFinish();
+          } else if (!isApproved) {
+            // it is needed to set notification after reloading the page
+            context.notifier({
+              eventType: 'check_approve_tx_status',
+              swap: swap,
+              step: currentStep
+            });
+          }
+          _context2.next = 16;
+          break;
+        case 12:
+          _context2.prev = 12;
+          _context2.t0 = _context2["catch"](4);
+          console.error('Failed to check getApprovedAmount', _context2.t0);
+          isApproved = false;
+        case 16:
+          if (!isApproved) {
+            _context2.next = 32;
+            break;
+          }
+          currentStep.status = 'approved';
+          swap.extraMessage = "Spending " + currentStep.fromSymbol + " approved successfully.";
+          swap.extraMessageDetail = null;
+          swap.extraMessageSeverity = exports.MessageSeverity.success;
+          currentStep.evmApprovalTransaction = null;
+          currentStep.executedTransactionId = null;
+          currentStep.executedTransactionTime = null;
+          currentStep.starknetApprovalTransaction = null;
+          currentStep.tronApprovalTransaction = null;
+          setStorage(_extends({}, getStorage(), {
+            swapDetails: swap
+          }));
+          context.notifier({
+            eventType: 'contract_confirmed',
+            swap: swap,
+            step: currentStep
+          });
+          schedule(SwapActionTypes.SCHEDULE_NEXT_STEP);
+          next();
+          _context2.next = 35;
+          break;
+        case 32:
+          _context2.next = 34;
+          return delay(2000);
+        case 34:
+          retry();
+        case 35:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2, null, [[4, 12]]);
+  }));
+  return _checkApprovalStatus.apply(this, arguments);
+}
+function checkStatus(_x3) {
+  return _checkStatus.apply(this, arguments);
+}
+function _checkStatus() {
+  _checkStatus = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(actions) {
+    var swap, currentStep;
+    return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+      while (1) switch (_context3.prev = _context3.next) {
+        case 0:
+          swap = actions.getStorage().swapDetails; // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+          currentStep = getCurrentStep(swap); // Reset network status
+          // Because when check status is on `loading` or `failed` status, it shows previous message that isn't related to current state.
+          resetNetworkStatus(actions);
+          if (!(currentStep.status === 'running')) {
+            _context3.next = 8;
+            break;
+          }
+          _context3.next = 6;
+          return checkTransactionStatus(actions);
+        case 6:
+          _context3.next = 11;
+          break;
+        case 8:
+          if (!(currentStep.status === 'waitingForApproval')) {
+            _context3.next = 11;
+            break;
+          }
+          _context3.next = 11;
+          return checkApprovalStatus(actions);
+        case 11:
+        case "end":
+          return _context3.stop();
+      }
+    }, _callee3);
+  }));
+  return _checkStatus.apply(this, arguments);
+}
+
+/**
+ *
+ * When a user asks for a swap, We first create the transaction by sending a request to server
+ * Server will return the transaction that need to be sent to wallet.
+ * It can be failed if server goes through an error, If not, we will schedule the `EXECTUTE_TRANSACTION`.
+ *
+ */
+function createTransaction(_x) {
+  return _createTransaction.apply(this, arguments);
+}
+function _createTransaction() {
+  _createTransaction = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(actions) {
+    var setStorage, getStorage, next, schedule, context, swap, currentStep, evmTransaction, cosmosTransaction, transferTransaction, evmApprovalTransaction, solanaTransaction, tronTransaction, tronApprovalTransaction, starknetTransaction, starknetApprovalTransaction, request, _yield$throwOnOK, transaction, _prettifyErrorMessage, extraMessage, extraMessageDetail, updateResult;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          setStorage = actions.setStorage, getStorage = actions.getStorage, next = actions.next, schedule = actions.schedule, context = actions.context;
+          swap = getStorage().swapDetails; // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+          currentStep = getCurrentStep(swap);
+          evmTransaction = currentStep.evmTransaction, cosmosTransaction = currentStep.cosmosTransaction, transferTransaction = currentStep.transferTransaction, evmApprovalTransaction = currentStep.evmApprovalTransaction, solanaTransaction = currentStep.solanaTransaction, tronTransaction = currentStep.tronTransaction, tronApprovalTransaction = currentStep.tronApprovalTransaction, starknetTransaction = currentStep.starknetTransaction, starknetApprovalTransaction = currentStep.starknetApprovalTransaction;
+          if (!(!evmTransaction && !evmApprovalTransaction && !tronTransaction && !tronApprovalTransaction && !starknetTransaction && !starknetApprovalTransaction && !cosmosTransaction && !transferTransaction && !solanaTransaction)) {
+            _context.next = 25;
+            break;
+          }
+          request = {
+            requestId: swap.requestId,
+            step: currentStep.id,
+            userSettings: {
+              slippage: swap.settings.slippage,
+              infiniteApprove: swap.settings.infiniteApprove
+            },
+            validations: {
+              balance: swap.validateBalanceOrFee,
+              fee: swap.validateBalanceOrFee
+            }
+          };
+          _context.prev = 6;
+          _context.next = 9;
+          return throwOnOK(httpService.createTransaction(request));
+        case 9:
+          _yield$throwOnOK = _context.sent;
+          transaction = _yield$throwOnOK.transaction;
+          if (transaction) {
+            if (isEvmTransaction(transaction)) {
+              if (transaction.isApprovalTx) currentStep.evmApprovalTransaction = transaction;else currentStep.evmTransaction = transaction;
+            } else if (isCosmosTransaction(transaction)) {
+              currentStep.cosmosTransaction = transaction;
+            } else if (isSolanaTransaction(transaction)) {
+              currentStep.solanaTransaction = transaction;
+            } else if (isTrasnferTransaction(transaction)) {
+              currentStep.transferTransaction = transaction;
+            } else if (isStarknetTransaction(transaction)) {
+              if (transaction.isApprovalTx) currentStep.starknetApprovalTransaction = transaction;else currentStep.starknetTransaction = transaction;
+            } else if (isTronTransaction(transaction)) {
+              if (transaction.isApprovalTx) currentStep.tronApprovalTransaction = transaction;else currentStep.tronTransaction = transaction;
+            }
+          }
+          setStorage(_extends({}, getStorage(), {
+            swapDetails: swap
+          }));
+          schedule(SwapActionTypes.EXECUTE_TRANSACTION);
+          next();
+          _context.next = 25;
+          break;
+        case 17:
+          _context.prev = 17;
+          _context.t0 = _context["catch"](6);
+          swap.status = 'failed';
+          swap.finishTime = new Date().getTime().toString();
+          _prettifyErrorMessage = prettifyErrorMessage(_context.t0), extraMessage = _prettifyErrorMessage.extraMessage, extraMessageDetail = _prettifyErrorMessage.extraMessageDetail;
+          updateResult = updateSwapStatus({
+            getStorage: getStorage,
+            setStorage: setStorage,
+            nextStatus: 'failed',
+            nextStepStatus: 'failed',
+            message: extraMessage,
+            details: extraMessageDetail,
+            errorCode: 'FETCH_TX_FAILED'
+          });
+          context.notifier(_extends({
+            eventType: 'task_failed'
+          }, updateResult));
+          actions.failed();
+        case 25:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee, null, [[6, 17]]);
+  }));
+  return _createTransaction.apply(this, arguments);
+}
+
+/**
+ * Excecute a created transaction.
+ *
+ * This function implemented the parallel mode by `claim` mechanism which means
+ * All the queues the meet certain situation (like multiple evm transaction) will go through
+ * a `claim` mechanims that decides which queue should be run and it blocks other ones.
+ *
+ * A queue will be go to sign process, if the wallet and network is matched.
+ */
+function executeTransaction(_x) {
+  return _executeTransaction.apply(this, arguments);
+}
+function _executeTransaction() {
+  _executeTransaction = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(actions) {
+    var _context$_queue;
+    var getStorage, context, meta, wallets, providers, isClaimed, requestBlock, swap, currentStep, isWrongAddress, _wallets$blockchains, _getRequiredWallet, type, address, isWalletInCompatible, description, blockedFor, needsToBlockQueue, _blockedFor, networkMatched, fromBlockchain, details, _blockedFor2;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          getStorage = actions.getStorage, context = actions.context;
+          meta = context.meta, wallets = context.wallets, providers = context.providers;
+          isClaimed = context.claimedBy === ((_context$_queue = context._queue) == null ? void 0 : _context$_queue.id);
+          requestBlock = function requestBlock(blockedFor) {
+            actions.block(blockedFor);
+            if (isClaimed && actions.context.resetClaimedBy) {
+              actions.context.resetClaimedBy();
+            }
+          };
+          swap = getStorage().swapDetails; // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+          currentStep = getCurrentStep(swap); // Resetting network status, so we will set it again during the running of this task.
+          resetNetworkStatus(actions);
+          /* Make sure wallet is connected and also the connected wallet is matched with tx by checking address. */
+          isWrongAddress = !isRequiredWalletConnected(swap, context.state).ok;
+          if (!isWrongAddress) {
+            _context.next = 15;
+            break;
+          }
+          _getRequiredWallet = getRequiredWallet(swap), type = _getRequiredWallet.type, address = _getRequiredWallet.address;
+          isWalletInCompatible = wallets == null ? void 0 : (_wallets$blockchains = wallets.blockchains) == null ? void 0 : _wallets$blockchains.find(function (w) {
+            var _w$accounts;
+            return !((_w$accounts = w.accounts) != null && _w$accounts.find(function (account) {
+              return account.walletType === type;
+            }));
+          });
+          description = !wallets || isWalletInCompatible ? ERROR_MESSAGE_WAIT_FOR_WALLET_DESCRIPTION(type) : ERROR_MESSAGE_WAIT_FOR_WALLET_DESCRIPTION_WRONG_WALLET(type, address);
+          blockedFor = {
+            reason: BlockReason.WAIT_FOR_CONNECT_WALLET,
+            description: description
+          };
+          requestBlock(blockedFor);
+          return _context.abrupt("return");
+        case 15:
+          /*
+          For avoiding conflict by making too many requests to wallet, we need to make sure
+          We only run one request at a time (In parallel mode).
+          */
+          needsToBlockQueue = isNeedBlockQueueForParallel(currentStep);
+          if (!(needsToBlockQueue && !isClaimed && context.claimedBy)) {
+            _context.next = 20;
+            break;
+          }
+          _blockedFor = {
+            reason: BlockReason.DEPENDS_ON_OTHER_QUEUES,
+            description: 'Waiting for other swaps to complete',
+            details: {}
+          };
+          requestBlock(_blockedFor);
+          return _context.abrupt("return");
+        case 20:
+          _context.next = 22;
+          return isNetworkMatchedForTransaction(swap, currentStep, wallets, meta, providers);
+        case 22:
+          networkMatched = _context.sent;
+          if (networkMatched) {
+            _context.next = 31;
+            break;
+          }
+          fromBlockchain = getCurrentBlockchainOf(swap, currentStep);
+          details = ERROR_MESSAGE_WAIT_FOR_CHANGE_NETWORK(fromBlockchain);
+          _blockedFor2 = {
+            reason: BlockReason.WAIT_FOR_NETWORK_CHANGE,
+            details: details
+          };
+          requestBlock(_blockedFor2);
+          return _context.abrupt("return");
+        case 31:
+          // Update network to mark it as network changed successfully.
+          updateNetworkStatus(actions, {
+            message: '',
+            details: 'Wallet network changed successfully',
+            status: exports.PendingSwapNetworkStatus.NetworkChanged
+          });
+        case 32:
+          // All the conditions are met. We can safely send the tx to wallet for sign.
+          singTransaction(actions);
+        case 33:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return _executeTransaction.apply(this, arguments);
+}
+
+/**
+ *
+ * This function is responsibe for scheduling the correct `action` based on `PendingSwap` status.
+ * It means `action`s schedule this step to decide what should be the next step/task.
+ *
+ * It's acts like a `while(true)` and will `break` the loop on certain `action`s like `CHECK_STATUS`.
+ *
+ *
+ */
+function scheduleNextStep(_ref) {
+  var schedule = _ref.schedule,
+    next = _ref.next,
+    failed = _ref.failed,
+    setStorage = _ref.setStorage,
+    getStorage = _ref.getStorage,
+    context = _ref.context;
+  var swap = getStorage().swapDetails;
+  var currentStep = getCurrentStep(swap);
+  if (!!currentStep) {
+    if (isTxAlreadyCreated(swap, currentStep)) {
+      schedule(SwapActionTypes.EXECUTE_TRANSACTION);
+      return next();
+    }
+    // TODO double check it after approval changes
+    if (currentStep != null && currentStep.executedTransactionId) {
+      schedule(SwapActionTypes.CHECK_TRANSACTION_STATUS);
+      return next();
+    }
+    swap.status = 'running';
+    setStorage(_extends({}, getStorage(), {
+      swapDetails: swap
+    }));
+    schedule(SwapActionTypes.CREATE_TRANSACTION);
+    next();
+  } else {
+    var isFailed = swap.steps.find(function (step) {
+      return step.status === 'failed';
+    });
+    swap.status = isFailed ? 'failed' : 'success';
+    swap.finishTime = new Date().getTime().toString();
+    setStorage(_extends({}, getStorage(), {
+      swapDetails: swap
+    }));
+    context.notifier({
+      eventType: isFailed ? 'task_failed' : 'task_completed',
+      swap: swap,
+      step: null
+    });
+    if (isFailed) failed();else next();
+  }
+}
+
+function start(_ref) {
+  var schedule = _ref.schedule,
+    next = _ref.next;
+  schedule(SwapActionTypes.SCHEDULE_NEXT_STEP);
+  next();
+}
+
+var _actions;
+/**
+ *
+ * The idea behind this queue is to be able dynamically add some steps.
+ * After running a swap, it can be blocked (like on waiting for switch netwrok)
+ *  or waits for something happend (like checking status of a transaction from server)
+ *
+ */
+var swapQueueDef = {
+  name: 'swap',
+  actions: (_actions = {}, _actions[SwapActionTypes.START] = start, _actions[SwapActionTypes.SCHEDULE_NEXT_STEP] = scheduleNextStep, _actions[SwapActionTypes.CREATE_TRANSACTION] = createTransaction, _actions[SwapActionTypes.EXECUTE_TRANSACTION] = executeTransaction, _actions[SwapActionTypes.CHECK_TRANSACTION_STATUS] = checkStatus, _actions),
+  run: [SwapActionTypes.START],
+  whenTaskBlocked: function whenTaskBlocked(event, meta) {
+    if (event.reason.reason === BlockReason.WAIT_FOR_CONNECT_WALLET) {
+      onBlockForConnectWallet(event, meta);
+    } else if (event.reason.reason === BlockReason.WAIT_FOR_NETWORK_CHANGE) {
+      onBlockForChangeNetwork(event, meta);
+    } else if (event.reason.reason === BlockReason.DEPENDS_ON_OTHER_QUEUES) {
+      onDependsOnOtherQueues(event, meta);
+    }
+  }
+};
+
+var MIGRATED_KEY = 'migratedToQueueManager';
+/**
+ *
+ * If `MIGRATED_KEY` is set, it means we already migrated data from localstorage.
+ *
+ */
+function migrated() {
+  return !!window.localStorage.getItem(MIGRATED_KEY);
+}
+function hasQueueManagerOnIDB() {
+  return _hasQueueManagerOnIDB.apply(this, arguments);
+}
+/**
+ *
+ * By calling this function, we first check if the data already migrated or not,
+ * If not, starting to migrating to IndexedDb with proper format that queue manager is understand.
+ *
+ */
+function _hasQueueManagerOnIDB() {
+  _hasQueueManagerOnIDB = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          _context.prev = 0;
+          _context.next = 3;
+          return window.indexedDB.databases();
+        case 3:
+          return _context.abrupt("return", _context.sent.map(function (db) {
+            return db.name;
+          }).includes(queueManagerCore.DB_NAME));
+        case 6:
+          _context.prev = 6;
+          _context.t0 = _context["catch"](0);
+          return _context.abrupt("return", false);
+        case 9:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee, null, [[0, 6]]);
+  }));
+  return _hasQueueManagerOnIDB.apply(this, arguments);
+}
+function migration() {
+  return _migration.apply(this, arguments);
+}
+function _migration() {
+  _migration = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2() {
+    var swapsFromStorage, hasIndexDB, swaps, convertedSwaps, persistor, promises;
+    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          swapsFromStorage = window.localStorage.getItem('pendingSwaps');
+          _context2.next = 3;
+          return hasQueueManagerOnIDB();
+        case 3:
+          hasIndexDB = _context2.sent;
+          if (!(!swapsFromStorage || migrated() || hasIndexDB)) {
+            _context2.next = 6;
+            break;
+          }
+          return _context2.abrupt("return", true);
+        case 6:
+          // For old users, but they didn't do any swaps yet.
+          swaps = JSON.parse(swapsFromStorage);
+          convertedSwaps = [];
+          swaps.forEach(function (swap) {
+            /*
+              For running task we need to add some more work
+              We need to create a queue task to be run and resume the running task from queue manager.
+             */
+            if (swap.status === 'running') {
+              var _tasks;
+              var taskId = uuid.v4();
+              var convertedSwap = {
+                id: swap.requestId,
+                createdAt: Number(swap.creationTime),
+                name: 'swap',
+                status: queueManagerCore.Status.RUNNING,
+                storage: {
+                  swapDetails: swap
+                },
+                state: {
+                  status: queueManagerCore.Status.RUNNING,
+                  activeTaskIndex: 0,
+                  tasks: (_tasks = {}, _tasks[taskId] = {
+                    blockedFor: null,
+                    status: queueManagerCore.Status.RUNNING
+                  }, _tasks)
+                },
+                tasks: [{
+                  id: taskId,
+                  action: SwapActionTypes.SCHEDULE_NEXT_STEP
+                }]
+              };
+              convertedSwaps.push(convertedSwap);
+            } else {
+              /*
+               * For failed or successful swaps, we only move it to IndexedDB,
+               * And there is no need to consider them to be run.
+               */
+              var status = swap.status === 'success' ? queueManagerCore.Status.SUCCESS : queueManagerCore.Status.FAILED;
+              var _convertedSwap = {
+                id: swap.requestId,
+                createdAt: Number(swap.creationTime),
+                name: 'swap',
+                status: status,
+                storage: {
+                  swapDetails: swap
+                },
+                state: {
+                  status: status,
+                  activeTaskIndex: 0,
+                  tasks: {}
+                },
+                tasks: []
+              };
+              convertedSwaps.push(_convertedSwap);
+            }
+          });
+          // Getting an instance from persistor, so we can directly put our data inside it.
+          persistor = new queueManagerCore.Persistor();
+          promises = convertedSwaps.map(function (queue) {
+            return persistor.insertQueue(queue);
+          });
+          _context2.next = 13;
+          return Promise.all(promises);
+        case 13:
+          // Mark as the data has been successfully migrated.
+          window.localStorage.setItem(MIGRATED_KEY, '1');
+          return _context2.abrupt("return", true);
+        case 15:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  }));
+  return _migration.apply(this, arguments);
+}
+
+var isCalled = 0;
+/**
+ *
+ * Runs a migration (old swaps from localstorage to queue manager's IndexedDB)
+ * It will be run only once on page load.
+ *
+ */
+function useMigration() {
+  var isMigrated = migrated();
+  var _useState = react.useState(isMigrated),
+    status = _useState[0],
+    setStatus = _useState[1];
+  react.useEffect(function () {
+    _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+      return _regeneratorRuntime().wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            if (!isCalled) {
+              _context.next = 2;
+              break;
+            }
+            return _context.abrupt("return");
+          case 2:
+            isCalled = 1;
+            migration()["finally"](function () {
+              setStatus(true);
+            });
+          case 4:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    }))();
+  }, []);
+  return {
+    status: status
+  };
+}
+/**
+ *
+ * On initial load and also connect/disconnet we may need to update swap's notified message.
+ * And also if a new wallet is connected we will retry the queue to see we can resume it or not.
+ *
+ */
+function useQueueManager(params) {
+  var _useManager = queueManagerReact.useManager(),
+    manager = _useManager.manager;
+  react.useEffect(function () {
+    if (params.lastConnectedWallet) {
+      checkWaitingForConnectWalletChange({
+        evmChains: params.evmChains,
+        wallet_network: params.lastConnectedWallet,
+        manager: manager,
+        notifier: params.notifier
+      });
+      retryOn(params.lastConnectedWallet, params.notifier, manager);
+    }
+  }, [params.lastConnectedWallet]);
+  react.useEffect(function () {
+    if (params.disconnectedWallet) {
+      checkWaitingForNetworkChange(manager);
+      /*
+        We need to reset the state value, so if a wallet disconnected twice (after reconnect),
+        this effect will be run properly.
+      */
+      params.clearDisconnectedWallet();
+    }
+  }, [params.disconnectedWallet]);
+}
+
+exports.PrettyError = PrettyError;
+exports.cancelSwap = cancelSwap;
+exports.checkWaitingForNetworkChange = checkWaitingForNetworkChange;
+exports.getCurrentBlockchainOfOrNull = getCurrentBlockchainOfOrNull;
+exports.getCurrentStep = getCurrentStep;
+exports.getEvmProvider = getEvmProvider;
+exports.getRelatedWallet = getRelatedWallet;
+exports.getRelatedWalletOrNull = getRelatedWalletOrNull;
+exports.getRequiredWallet = getRequiredWallet;
+exports.getRunningSwaps = getRunningSwaps;
+exports.prettifyErrorMessage = prettifyErrorMessage;
+exports.resetRunningSwapNotifsOnPageLoad = resetRunningSwapNotifsOnPageLoad;
+exports.splitWalletNetwork = splitWalletNetwork;
+exports.swapQueueDef = swapQueueDef;
+exports.updateSwapStatus = updateSwapStatus;
+exports.useMigration = useMigration;
+exports.useQueueManager = useQueueManager;
+//# sourceMappingURL=queue-manager-rango-preset.cjs.development.js.map