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

package/dist/queue-manager-rango-preset.esm.js

@@ -0,0 +1,2242 @@
+import BigNumber$1, { BigNumber } from 'bignumber.js';
+import { WalletError, isWalletErrorCode, WalletErrorCode, TransactionType, getBlockChainNameFromId, WalletType, Network } from '@rango-dev/wallets-shared';
+import { readAccountAddress } from '@rango-dev/wallets-core';
+import { Status } from '@rango-dev/queue-manager-core';
+import { captureException } from '@sentry/browser';
+
+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 = {}));
+
+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 RANGO_DAPP_ID_QUERY = process.env.REACT_APP_RANGO_DAPP_ID_QUERY;
+var BASE_URL = process.env.REACT_APP_BASE_URL;
+var RANGO_COOKIE_HEADER = 'X-Rango-Id';
+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 + ".";
+};
+
+var APIErrorCode;
+(function (APIErrorCode) {
+  APIErrorCode["TX_FAIL"] = "TX_FAIL";
+  APIErrorCode["FETCH_TX_FAILED"] = "FETCH_TX_FAILED";
+  APIErrorCode["USER_REJECT"] = "USER_REJECT";
+  APIErrorCode["CALL_WALLET_FAILED"] = "CALL_WALLET_FAILED";
+  APIErrorCode["SEND_TX_FAILED"] = "SEND_TX_FAILED";
+  APIErrorCode["CALL_OR_SEND_FAILED"] = "CALL_OR_SEND_FAILED";
+  APIErrorCode["USER_CANCEL"] = "USER_CANCEL";
+  APIErrorCode["CLIENT_UNEXPECTED_BEHAVIOUR"] = "CLIENT_UNEXPECTED_BEHAVIOUR";
+})(APIErrorCode || (APIErrorCode = {}));
+var ApiMethodName;
+(function (ApiMethodName) {
+  ApiMethodName["RequestingSwapTransaction"] = "Requesting Swap Transaction";
+  ApiMethodName["CreatingSwap"] = "Creating Swap";
+  ApiMethodName["CheckingTransactionStatus"] = "Checking transaction status";
+  ApiMethodName["CreateTransaction"] = "Create Transaction";
+  ApiMethodName["CheckApproval"] = "Check TX Approval";
+  ApiMethodName["GettingSwapDetail"] = "Getting Swap Detail";
+  ApiMethodName["GettingUserLimits"] = "Getting user limits";
+})(ApiMethodName || (ApiMethodName = {}));
+var TransactionName;
+(function (TransactionName) {
+  TransactionName["GenericTransaction"] = "transaction";
+  TransactionName["SendingOneInchTransaction"] = "1inch transaction";
+  TransactionName["Approval"] = "approve transaction";
+})(TransactionName || (TransactionName = {}));
+var ERROR_ASSERTION_FAILED = 'Assertion failed (Unexpected behaviour)';
+var ERROR_COMMUNICATING_WITH_API = function ERROR_COMMUNICATING_WITH_API(apiMethodName) {
+  return "Unexpected response from API (" + apiMethodName + ")";
+};
+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;
+    Object.setPrototypeOf(_assertThisInitialized(_this), PrettyError.prototype);
+    _this.code = code;
+    _this.detail = detail;
+    _this.root = root;
+    return _this;
+  }
+  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(APIErrorCode.CLIENT_UNEXPECTED_BEHAVIOUR, ERROR_ASSERTION_FAILED, m);
+  };
+  PrettyError.BadStatusCode = function BadStatusCode(message, statusCode) {
+    return new PrettyError(APIErrorCode.TX_FAIL, message, null, "status code = " + statusCode);
+  };
+  PrettyError.CreateTransaction = function CreateTransaction(detail) {
+    return new PrettyError(APIErrorCode.FETCH_TX_FAILED, ERROR_CREATE_TRANSACTION, null, detail);
+  };
+  PrettyError.WalletMissing = function WalletMissing() {
+    return new PrettyError(APIErrorCode.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(APIErrorCode.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));
+
+var PendingSwapNetworkStatus;
+(function (PendingSwapNetworkStatus) {
+  PendingSwapNetworkStatus["WaitingForConnectingWallet"] = "waitingForConnectingWallet";
+  PendingSwapNetworkStatus["WaitingForQueue"] = "waitingForQueue";
+  PendingSwapNetworkStatus["WaitingForNetworkChange"] = "waitingForNetworkChange";
+  PendingSwapNetworkStatus["NetworkChanged"] = "networkChanged";
+})(PendingSwapNetworkStatus || (PendingSwapNetworkStatus = {}));
+var MessageSeverity;
+(function (MessageSeverity) {
+  MessageSeverity["error"] = "error";
+  MessageSeverity["warning"] = "warning";
+  MessageSeverity["info"] = "info";
+  MessageSeverity["success"] = "success";
+})(MessageSeverity || (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 prettifyErrorMessage = function prettifyErrorMessage(obj) {
+  if (!obj) return {
+    extraMessage: '',
+    extraMessageErrorCode: null
+  };
+  if (obj instanceof PrettyError) return obj.getErrorDetail();
+  if (obj instanceof WalletError) {
+    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 getCookieId() {
+  var key = 'X-Rango-Id';
+  var cookieId = window.localStorage.getItem(key);
+  if (cookieId) {
+    return cookieId;
+  }
+  var value = Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
+  window.localStorage.setItem(key, value);
+  return value;
+}
+function getNextStep(swap, currentStep) {
+  return swap.steps.find(function (step) {
+    return step.status !== 'failed' && step.status !== 'success' && step.id !== currentStep.id;
+  }) || null;
+}
+function getRelatedWalletOrNull(swap, currentStep) {
+  try {
+    return getRelatedWallet(swap, currentStep);
+  } catch (e) {
+    return null;
+  }
+}
+
+function logRPCError(error, swap, currentStep, walletType) {
+  try {
+    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
+    });
+  }
+}
+
+function checkSwapStatus(_x, _x2, _x3) {
+  return _checkSwapStatus.apply(this, arguments);
+}
+function _checkSwapStatus() {
+  _checkSwapStatus = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(requestId, txId, step) {
+    var _headers;
+    var url, body, response, apiError, res;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          url = BASE_URL + "/tx/check-status?" + RANGO_DAPP_ID_QUERY;
+          body = {
+            step: step,
+            txId: txId,
+            requestId: requestId
+          };
+          _context.next = 4;
+          return fetch(url, {
+            method: 'POST',
+            headers: (_headers = {}, _headers[RANGO_COOKIE_HEADER] = getCookieId(), _headers['content-type'] = 'application/json;charset=UTF-8', _headers),
+            body: JSON.stringify(body)
+          });
+        case 4:
+          response = _context.sent;
+          if (!(!!response.status && (response.status < 200 || response.status >= 400) || !response.ok)) {
+            _context.next = 8;
+            break;
+          }
+          apiError = ERROR_COMMUNICATING_WITH_API(ApiMethodName.CheckingTransactionStatus);
+          throw PrettyError.BadStatusCode(apiError, response.status);
+        case 8:
+          _context.next = 10;
+          return response.json();
+        case 10:
+          res = _context.sent;
+          return _context.abrupt("return", _extends({}, res, {
+            outputAmount: res.outputAmount ? new BigNumber(res.outputAmount) : null
+          }));
+        case 12:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return _checkSwapStatus.apply(this, arguments);
+}
+function createTransaction(_x4) {
+  return _createTransaction.apply(this, arguments);
+}
+function _createTransaction() {
+  _createTransaction = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(request) {
+    var url, _headers2, response, result;
+    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          url = BASE_URL + "/tx/create?" + RANGO_DAPP_ID_QUERY;
+          _context2.prev = 1;
+          _context2.next = 4;
+          return fetch(url, {
+            method: 'POST',
+            headers: (_headers2 = {
+              'content-type': 'application/json;charset=UTF-8'
+            }, _headers2[RANGO_COOKIE_HEADER] = getCookieId(), _headers2),
+            body: JSON.stringify(request)
+          });
+        case 4:
+          response = _context2.sent;
+          if (!(!!response.status && (response.status < 200 || response.status >= 400) || !response.ok)) {
+            _context2.next = 7;
+            break;
+          }
+          throw PrettyError.CreateTransaction("Error creating the transaction, status code: " + response.status);
+        case 7:
+          _context2.next = 9;
+          return response.json();
+        case 9:
+          result = _context2.sent;
+          if (!(!result.ok || !result.transaction)) {
+            _context2.next = 12;
+            break;
+          }
+          throw PrettyError.CreateTransaction(result.error || 'bad response from create tx endpoint');
+        case 12:
+          return _context2.abrupt("return", result);
+        case 15:
+          _context2.prev = 15;
+          _context2.t0 = _context2["catch"](1);
+          if (!(_context2.t0 instanceof Error)) {
+            _context2.next = 19;
+            break;
+          }
+          throw PrettyError.CreateTransaction(_context2.t0.message);
+        case 19:
+          throw _context2.t0;
+        case 20:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2, null, [[1, 15]]);
+  }));
+  return _createTransaction.apply(this, arguments);
+}
+function checkApproved(_x5) {
+  return _checkApproved.apply(this, arguments);
+}
+function _checkApproved() {
+  _checkApproved = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(requestId) {
+    var _headers3;
+    var url, response, apiError;
+    return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+      while (1) switch (_context3.prev = _context3.next) {
+        case 0:
+          url = BASE_URL + "/tx/" + requestId + "/check-approval?" + RANGO_DAPP_ID_QUERY;
+          _context3.next = 3;
+          return fetch(url, {
+            method: 'GET',
+            headers: (_headers3 = {
+              'content-type': 'application/json;charset=UTF-8'
+            }, _headers3[RANGO_COOKIE_HEADER] = getCookieId(), _headers3)
+          });
+        case 3:
+          response = _context3.sent;
+          if (!(!!response.status && (response.status < 200 || response.status >= 400) || !response.ok)) {
+            _context3.next = 7;
+            break;
+          }
+          apiError = ERROR_COMMUNICATING_WITH_API(ApiMethodName.CheckApproval);
+          throw PrettyError.BadStatusCode(apiError, response.status);
+        case 7:
+          _context3.next = 9;
+          return response.json();
+        case 9:
+          return _context3.abrupt("return", _context3.sent);
+        case 10:
+        case "end":
+          return _context3.stop();
+      }
+    }, _callee3);
+  }));
+  return _checkApproved.apply(this, arguments);
+}
+function isAPIErrorCode(value) {
+  return Object.values(APIErrorCode).includes(value);
+}
+function mapAppErrorCodesToAPIErrorCode(errorCode) {
+  var defaultErrorCode = APIErrorCode.CLIENT_UNEXPECTED_BEHAVIOUR;
+  try {
+    if (!errorCode) return defaultErrorCode;
+    if (isAPIErrorCode(errorCode)) return errorCode;
+    if (isWalletErrorCode(errorCode)) {
+      var _t;
+      var t = (_t = {}, _t[WalletErrorCode.REJECTED_BY_USER] = APIErrorCode.USER_REJECT, _t[WalletErrorCode.SIGN_TX_ERROR] = APIErrorCode.CALL_WALLET_FAILED, _t[WalletErrorCode.SEND_TX_ERROR] = APIErrorCode.SEND_TX_FAILED, _t[WalletErrorCode.NOT_IMPLEMENTED] = defaultErrorCode, _t[WalletErrorCode.OPERATION_UNSUPPORTED] = defaultErrorCode, _t[WalletErrorCode.UNEXPECTED_BEHAVIOUR] = defaultErrorCode, _t);
+      return t[errorCode];
+    }
+    return defaultErrorCode;
+  } catch (err) {
+    return defaultErrorCode;
+  }
+}
+function reportFailed(_x6, _x7, _x8, _x9, _x10) {
+  return _reportFailed.apply(this, arguments);
+}
+function _reportFailed() {
+  _reportFailed = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4(requestId, step, eventType, reason, walletType) {
+    var _headers4;
+    var url;
+    return _regeneratorRuntime().wrap(function _callee4$(_context4) {
+      while (1) switch (_context4.prev = _context4.next) {
+        case 0:
+          url = BASE_URL + "/tx/report-tx?" + RANGO_DAPP_ID_QUERY;
+          _context4.next = 3;
+          return fetch(url, {
+            method: 'POST',
+            headers: (_headers4 = {
+              'content-type': 'application/json;charset=UTF-8'
+            }, _headers4[RANGO_COOKIE_HEADER] = getCookieId(), _headers4),
+            body: JSON.stringify({
+              requestId: requestId,
+              step: step,
+              eventType: eventType,
+              reason: reason,
+              tags: {
+                wallet: walletType
+              }
+            })
+          });
+        case 3:
+        case "end":
+          return _context4.stop();
+      }
+    }, _callee4);
+  }));
+  return _reportFailed.apply(this, arguments);
+}
+
+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;
+    }
+  };
+}
+/**
+ *
+ * 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;
+  var swap = getStorage().swapDetails;
+  var currentStep = getCurrentStep(swap);
+  if (!!nextStepStatus && !!currentStep) currentStep.status = nextStepStatus;
+  if (!!nextStatus) swap.status = nextStatus;
+  if (!!nextStatus && ['failed', 'success'].includes(nextStatus)) swap.finishTime = new Date().getTime().toString();
+  if (!!message) swap.extraMessage = message;
+  if (!!details) 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;
+    swap.extraMessageSeverity = MessageSeverity.error;
+    reportFailed(swap.requestId, (currentStep == null ? void 0 : currentStep.id) || 1, mapAppErrorCodesToAPIErrorCode(errorCode), errorReason || '', (currentStep ? (_getRelatedWalletOrNu = getRelatedWalletOrNull(swap, currentStep)) == null ? void 0 : _getRelatedWalletOrNu.walletType : null) || null).then();
+  } else if (!!nextStepStatus && ['running'].includes(nextStepStatus)) swap.extraMessageSeverity = MessageSeverity.info;else if (!!nextStepStatus && ['success', 'approved'].includes(nextStepStatus)) swap.extraMessageSeverity = MessageSeverity.success;else if (nextStepStatus && ['waitingForApproval'].includes(nextStepStatus)) swap.extraMessageSeverity = 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, eventType, notifier) {
+  var getStorage = _ref2.getStorage,
+    setStorage = _ref2.setStorage;
+  var swap = getStorage().swapDetails;
+  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+  var currentStep = getCurrentStep(swap);
+  currentStep.executedTransactionId = txId || currentStep.executedTransactionId;
+  setStorage(_extends({}, getStorage(), {
+    swapDetails: swap
+  }));
+  notifier({
+    eventType: eventType,
+    swap: swap,
+    step: currentStep
+  });
+}
+/**
+ * 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 === PendingSwapNetworkStatus.WaitingForConnectingWallet && swap.networkStatusExtraMessage === reason && swap.networkStatusExtraMessageDetail === reasonDetail;
+  if (isAlreadyMarked) {
+    return;
+  }
+  currentStep.networkStatus = 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 === 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 = 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;
+  var swap = getStorage().swapDetails;
+  var currentStep = getCurrentStep(swap);
+  if (!currentStep) return;
+  swap.networkStatusExtraMessage = '';
+  swap.networkStatusExtraMessageDetail = '';
+  currentStep.networkStatus = PendingSwapNetworkStatus.WaitingForQueue;
+  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 === TransactionType.EVM;
+};
+var isCosmosTransaction = function isCosmosTransaction(tx) {
+  return tx.type === TransactionType.COSMOS;
+};
+var isSolanaTransaction = function isSolanaTransaction(tx) {
+  return tx.type === TransactionType.SOLANA;
+};
+var isTrasnferTransaction = function isTrasnferTransaction(tx) {
+  return tx.type === TransactionType.TRANSFER;
+};
+var isStarknetTransaction = function isStarknetTransaction(tx) {
+  return tx.type === TransactionType.STARKNET;
+};
+var isTronTransaction = function isTronTransaction(tx) {
+  return tx.type === 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(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);
+}
+/**
+ * Returns the wallet address, based on the current step of `PendingSwap`.
+ */
+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 (![WalletType.META_MASK, WalletType.BINANCE_CHAIN, WalletType.XDEFI, WalletType.WALLET_CONNECT, WalletType.TRUST_WALLET, WalletType.COIN98, WalletType.EXODUS, WalletType.OKX, WalletType.COINBASE, WalletType.TOKEN_POCKET, WalletType.MATH, WalletType.SAFEPAL, WalletType.COSMOSTATION, WalletType.CLOVER, WalletType.BRAVE].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 = getBlockChainNameFromId(chainId, Object.entries(meta.blockchains).map(function (_ref7) {
+            var blockchainMeta = _ref7[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 getCurrentAddressOf = function getCurrentAddressOf(swap, step) {
+  var _step$evmTransaction, _step$evmApprovalTran, _step$cosmosTransacti, _step$solanaTransacti, _step$transferTransac, _step$transferTransac2;
+  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$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 && _step$transferTransac.fromWalletAddress ? {
+    address: (_step$transferTransac2 = step.transferTransaction) == null ? void 0 : _step$transferTransac2.fromWalletAddress
+  } : null) || null;
+  if (result == null) throw PrettyError.WalletMissing();
+  return result.address;
+};
+// Todo: Is it same with `getRequiredWallet`?
+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 (_ref6) {
+    var v = _ref6.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 === WalletType.UNKNOWN || wallet === null) throw PrettyError.AssertionFailed("Wallet for source " + blockchain + " not passed to transfer: walletType: " + walletType);
+  return wallet;
+}
+var isTxAlreadyCreated = function isTxAlreadyCreated(swap, step) {
+  var _step$evmTransaction2, _step$evmApprovalTran2, _step$cosmosTransacti2, _step$solanaTransacti2, _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$cosmosTransacti2 = step.cosmosTransaction) == null ? void 0 : _step$cosmosTransacti2.blockChain) || ''] || swap.wallets[((_step$solanaTransacti2 = step.solanaTransaction) == null ? void 0 : _step$solanaTransacti2.blockChain) || ''] || ((_step$transferTransac3 = step.transferTransaction) == null ? void 0 : _step$transferTransac3.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 walle),
+ * 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;
+  if (!isRequiredWalletConnected(swap, context.state)) {
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    var currentStep = getCurrentStep(swap);
+    context.notifier({
+      eventType: '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) 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 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;
+  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)
+    });
+    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, manager);
+    }
+  });
+}
+function isRequiredWalletConnected(swap, getState) {
+  var _getRequiredWallet4 = getRequiredWallet(swap),
+    type = _getRequiredWallet4.type,
+    address = _getRequiredWallet4.address;
+  if (!type || !address) {
+    return false;
+  }
+  var walletState = getState(type);
+  var accounts = walletState.accounts;
+  var connectedAccounts = accounts || [];
+  return connectedAccounts.some(function (account) {
+    var _readAccountAddress = readAccountAddress(account),
+      accountAddress = _readAccountAddress.address;
+    return address === accountAddress;
+  });
+}
+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;
+  var sourceWallet = getRelatedWallet(swap, currentStep);
+  var walletSigners = getSigners(sourceWallet.walletType);
+  var onFinish = function onFinish() {
+    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 === 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_contract'
+    }, updateResult));
+    // Execute transaction
+    walletSigners.executeEvmTransaction(evmApprovalTransaction, meta).then(function (hash) {
+      console.debug('transaction of approval minted successfully', hash);
+      var approveUrl = getEvmApproveUrl(hash, getCurrentBlockchainOf(swap, currentStep), meta.evmBasedChains);
+      currentStep.explorerUrl = [].concat(currentStep.explorerUrl || [], [{
+        url: approveUrl,
+        description: "approve"
+      }]);
+      // `currentStep` has been mutated, let's update storage.
+      setStorage(_extends({}, getStorage(), {
+        swapDetails: swap
+      }));
+      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;
+  }
+  var executeMessage = 'executing transaction';
+  var executeDetails = "" + (sourceWallet.walletType === WalletType.WALLET_CONNECT ? 'Check your mobile phone' : '');
+  if (!!transferTransaction) {
+    var _updateResult = updateSwapStatus({
+      getStorage: getStorage,
+      setStorage: setStorage,
+      nextStepStatus: 'running',
+      message: executeMessage,
+      details: executeDetails
+    });
+    notifier(_extends({
+      eventType: 'confirm_transfer'
+    }, _updateResult));
+    walletSigners.executeTransfer(transferTransaction, meta).then(function (txId) {
+      setStepTransactionIds(actions, txId, 'transfer_confirmed', notifier);
+      schedule(SwapActionTypes.CHECK_TRANSACTION_STATUS);
+      next();
+      onFinish();
+    }, function (error) {
+      if (swap.status === 'failed') return;
+      var _prettifyErrorMessage2 = prettifyErrorMessage(error),
+        extraMessage = _prettifyErrorMessage2.extraMessage,
+        extraMessageDetail = _prettifyErrorMessage2.extraMessageDetail,
+        extraMessageErrorCode = _prettifyErrorMessage2.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 _updateResult2 = updateSwapStatus({
+      getStorage: getStorage,
+      setStorage: setStorage,
+      nextStepStatus: 'running',
+      message: executeMessage,
+      details: executeDetails
+    });
+    notifier(_extends({
+      eventType: 'calling_smart_contract'
+    }, _updateResult2));
+    walletSigners.executeEvmTransaction(evmTransaction, meta).then(function (id) {
+      setStepTransactionIds(actions, id, 'smart_contract_called', notifier);
+      schedule(SwapActionTypes.CHECK_TRANSACTION_STATUS);
+      next();
+      onFinish();
+    }, function (error) {
+      var _error$root4, _error$root5, _error$root6;
+      if (swap.status === 'failed') return;
+      var _prettifyErrorMessage3 = prettifyErrorMessage(error),
+        extraMessage = _prettifyErrorMessage3.extraMessage,
+        extraMessageDetail = _prettifyErrorMessage3.extraMessageDetail,
+        extraMessageErrorCode = _prettifyErrorMessage3.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: 'smart_contract_call_failed'
+      }, updateResult));
+      failed();
+      onFinish();
+    });
+  } else if (!!cosmosTransaction) {
+    var _updateResult3 = updateSwapStatus({
+      getStorage: getStorage,
+      setStorage: setStorage,
+      nextStepStatus: 'running',
+      message: executeMessage,
+      details: executeDetails
+    });
+    notifier(_extends({
+      eventType: 'calling_smart_contract'
+    }, _updateResult3));
+    // 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) === Network.TERRA || (currentStep == null ? void 0 : currentStep.swapperId.toString()) === 'Terra Bridge' && currentStep.fromBlockchain === Network.TERRA) &&
+    // here we must allow ibc on terrastatus
+    sourceWallet.walletType === WalletType.KEPLR) {
+      var _prettifyErrorMessage4 = 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 = _prettifyErrorMessage4.extraMessage,
+        extraMessageDetail = _prettifyErrorMessage4.extraMessageDetail,
+        extraMessageErrorCode = _prettifyErrorMessage4.extraMessageErrorCode;
+      var _updateResult4 = updateSwapStatus({
+        getStorage: getStorage,
+        setStorage: setStorage,
+        nextStatus: 'failed',
+        nextStepStatus: 'failed',
+        message: extraMessage,
+        details: extraMessageDetail,
+        errorCode: extraMessageErrorCode
+      });
+      notifier(_extends({
+        eventType: 'smart_contract_call_failed'
+      }, _updateResult4));
+      failed();
+      onFinish();
+      return;
+    }
+    walletSigners.executeCosmosMessage(cosmosTransaction, meta).then(
+    // todo
+    function (id) {
+      setStepTransactionIds(actions, id, 'smart_contract_called', notifier);
+      schedule(SwapActionTypes.CHECK_TRANSACTION_STATUS);
+      next();
+      onFinish();
+    }, function (error) {
+      if (swap.status === 'failed') return;
+      var _prettifyErrorMessage5 = prettifyErrorMessage(error),
+        extraMessage = _prettifyErrorMessage5.extraMessage,
+        extraMessageDetail = _prettifyErrorMessage5.extraMessageDetail,
+        extraMessageErrorCode = _prettifyErrorMessage5.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 _updateResult5 = updateSwapStatus({
+      getStorage: getStorage,
+      setStorage: setStorage,
+      nextStepStatus: 'running',
+      message: executeMessage,
+      details: executeDetails
+    });
+    notifier(_extends({
+      eventType: 'calling_smart_contract'
+    }, _updateResult5));
+    var tx = solanaTransaction;
+    walletSigners.executeSolanaTransaction(tx, swap.requestId).then(function (txId) {
+      setStepTransactionIds(actions, txId, 'smart_contract_called', notifier);
+      schedule(SwapActionTypes.CHECK_TRANSACTION_STATUS);
+      next();
+      onFinish();
+    }, function (error) {
+      if (swap.status === 'failed') return;
+      var _prettifyErrorMessage6 = prettifyErrorMessage(error),
+        extraMessage = _prettifyErrorMessage6.extraMessage,
+        extraMessageDetail = _prettifyErrorMessage6.extraMessageDetail,
+        extraMessageErrorCode = _prettifyErrorMessage6.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();
+    });
+  }
+}
+/**
+ *
+ * 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, manager, options) {
+  var _finalQueueToBeRun;
+  if (options === void 0) {
+    options = {
+      fallbackToOnlyWallet: true
+    };
+  }
+  var _wallet_network$split2 = wallet_network.split('-'),
+    wallet = _wallet_network$split2[0],
+    network = _wallet_network$split2[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 === Status.BLOCKED) {
+      var queueStorage = q.list.getStorage();
+      var swap = queueStorage == null ? void 0 : queueStorage.swapDetails;
+      if (swap) {
+        var currentStep = getCurrentStep(swap);
+        if (currentStep) {
+          var _queueStorage$swapDet2, _queueStorage$swapDet3;
+          if (currentStep.fromBlockchain == 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);
+          }
+        }
+      }
+    }
+  });
+  // const isWaitingForConnectWallet = (status: Status) =>
+  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)
+        });
+      }
+    }
+  } 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;
+}
+
+var INTERVAL_FOR_CHECK = 2000;
+/**
+ * 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 checkSwapStatus(swap.requestId, txId, 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 ? new BigNumber$1(currentStep.outputAmount) : null);
+          prevOutputAmount = currentStep.outputAmount;
+          swap.extraMessage = ((_status2 = status) == null ? void 0 : _status2.extraMessage) || swap.extraMessage;
+          swap.extraMessageSeverity = 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 == null ? void 0 : outputAmount.toFixed()) || 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.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
+          });
+          if (currentStep.status === 'success') {
+            nextStep = getNextStep(swap, currentStep);
+            swap.extraMessageDetail = '';
+            swap.extraMessage = !!nextStep ? "starting next step: " + nextStep.swapperId + ": " + nextStep.fromBlockchain + " -> " + nextStep.toBlockchain : '';
+          }
+          // 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, context, swap, currentStep, isApproved, response;
+    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, context = _ref2.context;
+          swap = getStorage().swapDetails; // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+          currentStep = getCurrentStep(swap);
+          isApproved = false;
+          _context2.prev = 4;
+          _context2.next = 7;
+          return checkApproved(swap.requestId);
+        case 7:
+          response = _context2.sent;
+          isApproved = response.isApproved;
+          _context2.next = 14;
+          break;
+        case 11:
+          _context2.prev = 11;
+          _context2.t0 = _context2["catch"](4);
+          console.error('Failed to check getApprovedAmount', _context2.t0);
+        case 14:
+          if (!isApproved) {
+            _context2.next = 27;
+            break;
+          }
+          currentStep.status = 'approved';
+          swap.extraMessage = "Spending " + currentStep.fromSymbol + " approved successfully.";
+          swap.extraMessageDetail = null;
+          swap.extraMessageSeverity = MessageSeverity.success;
+          currentStep.evmApprovalTransaction = null;
+          currentStep.executedTransactionId = null;
+          setStorage(_extends({}, getStorage(), {
+            swapDetails: swap
+          }));
+          context.notifier({
+            eventType: 'contract_confirmed',
+            swap: swap,
+            step: currentStep
+          });
+          schedule(SwapActionTypes.SCHEDULE_NEXT_STEP);
+          next();
+          _context2.next = 30;
+          break;
+        case 27:
+          _context2.next = 29;
+          return delay(2000);
+        case 29:
+          retry();
+        case 30:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2, null, [[4, 11]]);
+  }));
+  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$1(_x) {
+  return _createTransaction$1.apply(this, arguments);
+}
+function _createTransaction$1() {
+  _createTransaction$1 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(actions) {
+    var setStorage, getStorage, next, schedule, context, swap, currentStep, evmTransaction, cosmosTransaction, transferTransaction, evmApprovalTransaction, solanaTransaction, request, _yield$requestTransac, 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;
+          if (!(!evmTransaction && !cosmosTransaction && !transferTransaction && !evmApprovalTransaction && !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 createTransaction(request);
+        case 9:
+          _yield$requestTransac = _context.sent;
+          transaction = _yield$requestTransac.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;
+            }
+          }
+          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: APIErrorCode.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$1.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, _getRequiredWallet, type, address, 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);
+          if (!isWrongAddress) {
+            _context.next = 14;
+            break;
+          }
+          _getRequiredWallet = getRequiredWallet(swap), type = _getRequiredWallet.type, address = _getRequiredWallet.address;
+          description = !wallets ? 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 14:
+          /*
+          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 = 19;
+            break;
+          }
+          _blockedFor = {
+            reason: BlockReason.DEPENDS_ON_OTHER_QUEUES,
+            description: 'Waiting for other running tasks to be finished',
+            details: {}
+          };
+          requestBlock(_blockedFor);
+          return _context.abrupt("return");
+        case 19:
+          _context.next = 21;
+          return isNetworkMatchedForTransaction(swap, currentStep, wallets, meta, providers);
+        case 21:
+          networkMatched = _context.sent;
+          if (networkMatched) {
+            _context.next = 30;
+            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 30:
+          // Update network to mark it as network changed successfully.
+          updateNetworkStatus(actions, {
+            message: '',
+            details: 'Wallet network changed successfully',
+            status: PendingSwapNetworkStatus.NetworkChanged
+          });
+        case 31:
+          // All the conditions are met. We can safely send the tx to wallet for sign.
+          singTransaction(actions);
+        case 32:
+        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();
+    }
+    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$1, _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);
+    }
+  }
+};
+
+export { swapQueueDef };
+//# sourceMappingURL=queue-manager-rango-preset.esm.js.map