@stakekit/widget 0.0.125 → 0.0.126

package/dist/package/index.package.js

@@ -3582,13 +3582,13 @@ var SettingsContextProvider = ({
   return /* @__PURE__ */ jsx(SettingsContext.Provider, { value, children });
 };
 var useSettings = () => {
-  const context = useContext(SettingsContext);
-  if (!context) {
+  const context2 = useContext(SettingsContext);
+  if (!context2) {
     throw new Error(
       "useSettings must be used within a SettingsContextProvider"
     );
   }
-  return context;
+  return context2;
 };
 
 // node_modules/@stakekit/api-hooks/dist/chunk-T2YKRUIH.js
@@ -3616,7 +3616,7 @@ var useApiClient = () => {
 };
 var useApi = () => {
   const apiClient = useApiClient();
-  return (config2) => apiClient(config2).then((response) => response.data);
+  return (config3) => apiClient(config3).then((response) => response.data);
 };
 var useActionGetGasEstimateHook = () => {
   const actionGetGasEstimate = useApi();
@@ -3968,9 +3968,9 @@ var checkDelay = () => {
     unsub = subscribe(() => res(null));
   }).then(() => unsub());
 };
-var attachDelayInterceptor = (apiClient) => apiClient.interceptors.request.use(async (config2) => {
+var attachDelayInterceptor = (apiClient) => apiClient.interceptors.request.use(async (config3) => {
   await checkDelay();
-  return config2;
+  return config3;
 });
 var delayAPIRequests = () => {
   if (config.env.isTestMode)
@@ -4021,7 +4021,843 @@ var useGeoBlock = () => useSyncExternalStore(
 
 // src/hooks/use-rich-errors.ts
 import { useCallback as useCallback2, useSyncExternalStore as useSyncExternalStore2 } from "react";
-import { BehaviorSubject } from "rxjs";
+
+// node_modules/rxjs/dist/esm5/internal/Subscriber.js
+import { __extends } from "tslib";
+
+// node_modules/rxjs/dist/esm5/internal/util/isFunction.js
+function isFunction(value) {
+  return typeof value === "function";
+}
+
+// node_modules/rxjs/dist/esm5/internal/Subscription.js
+import { __read, __spreadArray, __values } from "tslib";
+
+// node_modules/rxjs/dist/esm5/internal/util/createErrorClass.js
+function createErrorClass(createImpl) {
+  var _super = function(instance) {
+    Error.call(instance);
+    instance.stack = new Error().stack;
+  };
+  var ctorFunc = createImpl(_super);
+  ctorFunc.prototype = Object.create(Error.prototype);
+  ctorFunc.prototype.constructor = ctorFunc;
+  return ctorFunc;
+}
+
+// node_modules/rxjs/dist/esm5/internal/util/UnsubscriptionError.js
+var UnsubscriptionError = createErrorClass(function(_super) {
+  return function UnsubscriptionErrorImpl(errors) {
+    _super(this);
+    this.message = errors ? errors.length + " errors occurred during unsubscription:\n" + errors.map(function(err, i) {
+      return i + 1 + ") " + err.toString();
+    }).join("\n  ") : "";
+    this.name = "UnsubscriptionError";
+    this.errors = errors;
+  };
+});
+
+// node_modules/rxjs/dist/esm5/internal/util/arrRemove.js
+function arrRemove(arr, item) {
+  if (arr) {
+    var index = arr.indexOf(item);
+    0 <= index && arr.splice(index, 1);
+  }
+}
+
+// node_modules/rxjs/dist/esm5/internal/Subscription.js
+var Subscription = function() {
+  function Subscription2(initialTeardown) {
+    this.initialTeardown = initialTeardown;
+    this.closed = false;
+    this._parentage = null;
+    this._finalizers = null;
+  }
+  Subscription2.prototype.unsubscribe = function() {
+    var e_1, _a2, e_2, _b;
+    var errors;
+    if (!this.closed) {
+      this.closed = true;
+      var _parentage = this._parentage;
+      if (_parentage) {
+        this._parentage = null;
+        if (Array.isArray(_parentage)) {
+          try {
+            for (var _parentage_1 = __values(_parentage), _parentage_1_1 = _parentage_1.next(); !_parentage_1_1.done; _parentage_1_1 = _parentage_1.next()) {
+              var parent_1 = _parentage_1_1.value;
+              parent_1.remove(this);
+            }
+          } catch (e_1_1) {
+            e_1 = { error: e_1_1 };
+          } finally {
+            try {
+              if (_parentage_1_1 && !_parentage_1_1.done && (_a2 = _parentage_1.return))
+                _a2.call(_parentage_1);
+            } finally {
+              if (e_1)
+                throw e_1.error;
+            }
+          }
+        } else {
+          _parentage.remove(this);
+        }
+      }
+      var initialFinalizer = this.initialTeardown;
+      if (isFunction(initialFinalizer)) {
+        try {
+          initialFinalizer();
+        } catch (e) {
+          errors = e instanceof UnsubscriptionError ? e.errors : [e];
+        }
+      }
+      var _finalizers = this._finalizers;
+      if (_finalizers) {
+        this._finalizers = null;
+        try {
+          for (var _finalizers_1 = __values(_finalizers), _finalizers_1_1 = _finalizers_1.next(); !_finalizers_1_1.done; _finalizers_1_1 = _finalizers_1.next()) {
+            var finalizer = _finalizers_1_1.value;
+            try {
+              execFinalizer(finalizer);
+            } catch (err) {
+              errors = errors !== null && errors !== void 0 ? errors : [];
+              if (err instanceof UnsubscriptionError) {
+                errors = __spreadArray(__spreadArray([], __read(errors)), __read(err.errors));
+              } else {
+                errors.push(err);
+              }
+            }
+          }
+        } catch (e_2_1) {
+          e_2 = { error: e_2_1 };
+        } finally {
+          try {
+            if (_finalizers_1_1 && !_finalizers_1_1.done && (_b = _finalizers_1.return))
+              _b.call(_finalizers_1);
+          } finally {
+            if (e_2)
+              throw e_2.error;
+          }
+        }
+      }
+      if (errors) {
+        throw new UnsubscriptionError(errors);
+      }
+    }
+  };
+  Subscription2.prototype.add = function(teardown) {
+    var _a2;
+    if (teardown && teardown !== this) {
+      if (this.closed) {
+        execFinalizer(teardown);
+      } else {
+        if (teardown instanceof Subscription2) {
+          if (teardown.closed || teardown._hasParent(this)) {
+            return;
+          }
+          teardown._addParent(this);
+        }
+        (this._finalizers = (_a2 = this._finalizers) !== null && _a2 !== void 0 ? _a2 : []).push(teardown);
+      }
+    }
+  };
+  Subscription2.prototype._hasParent = function(parent) {
+    var _parentage = this._parentage;
+    return _parentage === parent || Array.isArray(_parentage) && _parentage.includes(parent);
+  };
+  Subscription2.prototype._addParent = function(parent) {
+    var _parentage = this._parentage;
+    this._parentage = Array.isArray(_parentage) ? (_parentage.push(parent), _parentage) : _parentage ? [_parentage, parent] : parent;
+  };
+  Subscription2.prototype._removeParent = function(parent) {
+    var _parentage = this._parentage;
+    if (_parentage === parent) {
+      this._parentage = null;
+    } else if (Array.isArray(_parentage)) {
+      arrRemove(_parentage, parent);
+    }
+  };
+  Subscription2.prototype.remove = function(teardown) {
+    var _finalizers = this._finalizers;
+    _finalizers && arrRemove(_finalizers, teardown);
+    if (teardown instanceof Subscription2) {
+      teardown._removeParent(this);
+    }
+  };
+  Subscription2.EMPTY = function() {
+    var empty = new Subscription2();
+    empty.closed = true;
+    return empty;
+  }();
+  return Subscription2;
+}();
+var EMPTY_SUBSCRIPTION = Subscription.EMPTY;
+function isSubscription(value) {
+  return value instanceof Subscription || value && "closed" in value && isFunction(value.remove) && isFunction(value.add) && isFunction(value.unsubscribe);
+}
+function execFinalizer(finalizer) {
+  if (isFunction(finalizer)) {
+    finalizer();
+  } else {
+    finalizer.unsubscribe();
+  }
+}
+
+// node_modules/rxjs/dist/esm5/internal/config.js
+var config2 = {
+  onUnhandledError: null,
+  onStoppedNotification: null,
+  Promise: void 0,
+  useDeprecatedSynchronousErrorHandling: false,
+  useDeprecatedNextContext: false
+};
+
+// node_modules/rxjs/dist/esm5/internal/scheduler/timeoutProvider.js
+import { __read as __read2, __spreadArray as __spreadArray2 } from "tslib";
+var timeoutProvider = {
+  setTimeout: function(handler, timeout) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+      args[_i - 2] = arguments[_i];
+    }
+    var delegate = timeoutProvider.delegate;
+    if (delegate === null || delegate === void 0 ? void 0 : delegate.setTimeout) {
+      return delegate.setTimeout.apply(delegate, __spreadArray2([handler, timeout], __read2(args)));
+    }
+    return setTimeout.apply(void 0, __spreadArray2([handler, timeout], __read2(args)));
+  },
+  clearTimeout: function(handle) {
+    var delegate = timeoutProvider.delegate;
+    return ((delegate === null || delegate === void 0 ? void 0 : delegate.clearTimeout) || clearTimeout)(handle);
+  },
+  delegate: void 0
+};
+
+// node_modules/rxjs/dist/esm5/internal/util/reportUnhandledError.js
+function reportUnhandledError(err) {
+  timeoutProvider.setTimeout(function() {
+    var onUnhandledError = config2.onUnhandledError;
+    if (onUnhandledError) {
+      onUnhandledError(err);
+    } else {
+      throw err;
+    }
+  });
+}
+
+// node_modules/rxjs/dist/esm5/internal/util/noop.js
+function noop() {
+}
+
+// node_modules/rxjs/dist/esm5/internal/NotificationFactories.js
+var COMPLETE_NOTIFICATION = function() {
+  return createNotification("C", void 0, void 0);
+}();
+function errorNotification(error) {
+  return createNotification("E", void 0, error);
+}
+function nextNotification(value) {
+  return createNotification("N", value, void 0);
+}
+function createNotification(kind, value, error) {
+  return {
+    kind,
+    value,
+    error
+  };
+}
+
+// node_modules/rxjs/dist/esm5/internal/util/errorContext.js
+var context = null;
+function errorContext(cb) {
+  if (config2.useDeprecatedSynchronousErrorHandling) {
+    var isRoot = !context;
+    if (isRoot) {
+      context = { errorThrown: false, error: null };
+    }
+    cb();
+    if (isRoot) {
+      var _a2 = context, errorThrown = _a2.errorThrown, error = _a2.error;
+      context = null;
+      if (errorThrown) {
+        throw error;
+      }
+    }
+  } else {
+    cb();
+  }
+}
+function captureError(err) {
+  if (config2.useDeprecatedSynchronousErrorHandling && context) {
+    context.errorThrown = true;
+    context.error = err;
+  }
+}
+
+// node_modules/rxjs/dist/esm5/internal/Subscriber.js
+var Subscriber = function(_super) {
+  __extends(Subscriber2, _super);
+  function Subscriber2(destination) {
+    var _this = _super.call(this) || this;
+    _this.isStopped = false;
+    if (destination) {
+      _this.destination = destination;
+      if (isSubscription(destination)) {
+        destination.add(_this);
+      }
+    } else {
+      _this.destination = EMPTY_OBSERVER;
+    }
+    return _this;
+  }
+  Subscriber2.create = function(next, error, complete) {
+    return new SafeSubscriber(next, error, complete);
+  };
+  Subscriber2.prototype.next = function(value) {
+    if (this.isStopped) {
+      handleStoppedNotification(nextNotification(value), this);
+    } else {
+      this._next(value);
+    }
+  };
+  Subscriber2.prototype.error = function(err) {
+    if (this.isStopped) {
+      handleStoppedNotification(errorNotification(err), this);
+    } else {
+      this.isStopped = true;
+      this._error(err);
+    }
+  };
+  Subscriber2.prototype.complete = function() {
+    if (this.isStopped) {
+      handleStoppedNotification(COMPLETE_NOTIFICATION, this);
+    } else {
+      this.isStopped = true;
+      this._complete();
+    }
+  };
+  Subscriber2.prototype.unsubscribe = function() {
+    if (!this.closed) {
+      this.isStopped = true;
+      _super.prototype.unsubscribe.call(this);
+      this.destination = null;
+    }
+  };
+  Subscriber2.prototype._next = function(value) {
+    this.destination.next(value);
+  };
+  Subscriber2.prototype._error = function(err) {
+    try {
+      this.destination.error(err);
+    } finally {
+      this.unsubscribe();
+    }
+  };
+  Subscriber2.prototype._complete = function() {
+    try {
+      this.destination.complete();
+    } finally {
+      this.unsubscribe();
+    }
+  };
+  return Subscriber2;
+}(Subscription);
+var _bind = Function.prototype.bind;
+function bind(fn11, thisArg) {
+  return _bind.call(fn11, thisArg);
+}
+var ConsumerObserver = function() {
+  function ConsumerObserver2(partialObserver) {
+    this.partialObserver = partialObserver;
+  }
+  ConsumerObserver2.prototype.next = function(value) {
+    var partialObserver = this.partialObserver;
+    if (partialObserver.next) {
+      try {
+        partialObserver.next(value);
+      } catch (error) {
+        handleUnhandledError(error);
+      }
+    }
+  };
+  ConsumerObserver2.prototype.error = function(err) {
+    var partialObserver = this.partialObserver;
+    if (partialObserver.error) {
+      try {
+        partialObserver.error(err);
+      } catch (error) {
+        handleUnhandledError(error);
+      }
+    } else {
+      handleUnhandledError(err);
+    }
+  };
+  ConsumerObserver2.prototype.complete = function() {
+    var partialObserver = this.partialObserver;
+    if (partialObserver.complete) {
+      try {
+        partialObserver.complete();
+      } catch (error) {
+        handleUnhandledError(error);
+      }
+    }
+  };
+  return ConsumerObserver2;
+}();
+var SafeSubscriber = function(_super) {
+  __extends(SafeSubscriber2, _super);
+  function SafeSubscriber2(observerOrNext, error, complete) {
+    var _this = _super.call(this) || this;
+    var partialObserver;
+    if (isFunction(observerOrNext) || !observerOrNext) {
+      partialObserver = {
+        next: observerOrNext !== null && observerOrNext !== void 0 ? observerOrNext : void 0,
+        error: error !== null && error !== void 0 ? error : void 0,
+        complete: complete !== null && complete !== void 0 ? complete : void 0
+      };
+    } else {
+      var context_1;
+      if (_this && config2.useDeprecatedNextContext) {
+        context_1 = Object.create(observerOrNext);
+        context_1.unsubscribe = function() {
+          return _this.unsubscribe();
+        };
+        partialObserver = {
+          next: observerOrNext.next && bind(observerOrNext.next, context_1),
+          error: observerOrNext.error && bind(observerOrNext.error, context_1),
+          complete: observerOrNext.complete && bind(observerOrNext.complete, context_1)
+        };
+      } else {
+        partialObserver = observerOrNext;
+      }
+    }
+    _this.destination = new ConsumerObserver(partialObserver);
+    return _this;
+  }
+  return SafeSubscriber2;
+}(Subscriber);
+function handleUnhandledError(error) {
+  if (config2.useDeprecatedSynchronousErrorHandling) {
+    captureError(error);
+  } else {
+    reportUnhandledError(error);
+  }
+}
+function defaultErrorHandler(err) {
+  throw err;
+}
+function handleStoppedNotification(notification, subscriber) {
+  var onStoppedNotification = config2.onStoppedNotification;
+  onStoppedNotification && timeoutProvider.setTimeout(function() {
+    return onStoppedNotification(notification, subscriber);
+  });
+}
+var EMPTY_OBSERVER = {
+  closed: true,
+  next: noop,
+  error: defaultErrorHandler,
+  complete: noop
+};
+
+// node_modules/rxjs/dist/esm5/internal/symbol/observable.js
+var observable = function() {
+  return typeof Symbol === "function" && Symbol.observable || "@@observable";
+}();
+
+// node_modules/rxjs/dist/esm5/internal/util/identity.js
+function identity(x2) {
+  return x2;
+}
+
+// node_modules/rxjs/dist/esm5/internal/util/pipe.js
+function pipeFromArray(fns) {
+  if (fns.length === 0) {
+    return identity;
+  }
+  if (fns.length === 1) {
+    return fns[0];
+  }
+  return function piped(input2) {
+    return fns.reduce(function(prev, fn11) {
+      return fn11(prev);
+    }, input2);
+  };
+}
+
+// node_modules/rxjs/dist/esm5/internal/Observable.js
+var Observable = function() {
+  function Observable3(subscribe3) {
+    if (subscribe3) {
+      this._subscribe = subscribe3;
+    }
+  }
+  Observable3.prototype.lift = function(operator) {
+    var observable2 = new Observable3();
+    observable2.source = this;
+    observable2.operator = operator;
+    return observable2;
+  };
+  Observable3.prototype.subscribe = function(observerOrNext, error, complete) {
+    var _this = this;
+    var subscriber = isSubscriber(observerOrNext) ? observerOrNext : new SafeSubscriber(observerOrNext, error, complete);
+    errorContext(function() {
+      var _a2 = _this, operator = _a2.operator, source = _a2.source;
+      subscriber.add(operator ? operator.call(subscriber, source) : source ? _this._subscribe(subscriber) : _this._trySubscribe(subscriber));
+    });
+    return subscriber;
+  };
+  Observable3.prototype._trySubscribe = function(sink) {
+    try {
+      return this._subscribe(sink);
+    } catch (err) {
+      sink.error(err);
+    }
+  };
+  Observable3.prototype.forEach = function(next, promiseCtor) {
+    var _this = this;
+    promiseCtor = getPromiseCtor(promiseCtor);
+    return new promiseCtor(function(resolve, reject) {
+      var subscriber = new SafeSubscriber({
+        next: function(value) {
+          try {
+            next(value);
+          } catch (err) {
+            reject(err);
+            subscriber.unsubscribe();
+          }
+        },
+        error: reject,
+        complete: resolve
+      });
+      _this.subscribe(subscriber);
+    });
+  };
+  Observable3.prototype._subscribe = function(subscriber) {
+    var _a2;
+    return (_a2 = this.source) === null || _a2 === void 0 ? void 0 : _a2.subscribe(subscriber);
+  };
+  Observable3.prototype[observable] = function() {
+    return this;
+  };
+  Observable3.prototype.pipe = function() {
+    var operations = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+      operations[_i] = arguments[_i];
+    }
+    return pipeFromArray(operations)(this);
+  };
+  Observable3.prototype.toPromise = function(promiseCtor) {
+    var _this = this;
+    promiseCtor = getPromiseCtor(promiseCtor);
+    return new promiseCtor(function(resolve, reject) {
+      var value;
+      _this.subscribe(function(x2) {
+        return value = x2;
+      }, function(err) {
+        return reject(err);
+      }, function() {
+        return resolve(value);
+      });
+    });
+  };
+  Observable3.create = function(subscribe3) {
+    return new Observable3(subscribe3);
+  };
+  return Observable3;
+}();
+function getPromiseCtor(promiseCtor) {
+  var _a2;
+  return (_a2 = promiseCtor !== null && promiseCtor !== void 0 ? promiseCtor : config2.Promise) !== null && _a2 !== void 0 ? _a2 : Promise;
+}
+function isObserver(value) {
+  return value && isFunction(value.next) && isFunction(value.error) && isFunction(value.complete);
+}
+function isSubscriber(value) {
+  return value && value instanceof Subscriber || isObserver(value) && isSubscription(value);
+}
+
+// node_modules/rxjs/dist/esm5/internal/util/lift.js
+function hasLift(source) {
+  return isFunction(source === null || source === void 0 ? void 0 : source.lift);
+}
+function operate(init) {
+  return function(source) {
+    if (hasLift(source)) {
+      return source.lift(function(liftedSource) {
+        try {
+          return init(liftedSource, this);
+        } catch (err) {
+          this.error(err);
+        }
+      });
+    }
+    throw new TypeError("Unable to lift unknown Observable type");
+  };
+}
+
+// node_modules/rxjs/dist/esm5/internal/operators/OperatorSubscriber.js
+import { __extends as __extends2 } from "tslib";
+function createOperatorSubscriber(destination, onNext, onComplete, onError, onFinalize) {
+  return new OperatorSubscriber(destination, onNext, onComplete, onError, onFinalize);
+}
+var OperatorSubscriber = function(_super) {
+  __extends2(OperatorSubscriber2, _super);
+  function OperatorSubscriber2(destination, onNext, onComplete, onError, onFinalize, shouldUnsubscribe) {
+    var _this = _super.call(this, destination) || this;
+    _this.onFinalize = onFinalize;
+    _this.shouldUnsubscribe = shouldUnsubscribe;
+    _this._next = onNext ? function(value) {
+      try {
+        onNext(value);
+      } catch (err) {
+        destination.error(err);
+      }
+    } : _super.prototype._next;
+    _this._error = onError ? function(err) {
+      try {
+        onError(err);
+      } catch (err2) {
+        destination.error(err2);
+      } finally {
+        this.unsubscribe();
+      }
+    } : _super.prototype._error;
+    _this._complete = onComplete ? function() {
+      try {
+        onComplete();
+      } catch (err) {
+        destination.error(err);
+      } finally {
+        this.unsubscribe();
+      }
+    } : _super.prototype._complete;
+    return _this;
+  }
+  OperatorSubscriber2.prototype.unsubscribe = function() {
+    var _a2;
+    if (!this.shouldUnsubscribe || this.shouldUnsubscribe()) {
+      var closed_1 = this.closed;
+      _super.prototype.unsubscribe.call(this);
+      !closed_1 && ((_a2 = this.onFinalize) === null || _a2 === void 0 ? void 0 : _a2.call(this));
+    }
+  };
+  return OperatorSubscriber2;
+}(Subscriber);
+
+// node_modules/rxjs/dist/esm5/internal/Subject.js
+import { __extends as __extends3, __values as __values2 } from "tslib";
+
+// node_modules/rxjs/dist/esm5/internal/util/ObjectUnsubscribedError.js
+var ObjectUnsubscribedError = createErrorClass(function(_super) {
+  return function ObjectUnsubscribedErrorImpl() {
+    _super(this);
+    this.name = "ObjectUnsubscribedError";
+    this.message = "object unsubscribed";
+  };
+});
+
+// node_modules/rxjs/dist/esm5/internal/Subject.js
+var Subject = function(_super) {
+  __extends3(Subject2, _super);
+  function Subject2() {
+    var _this = _super.call(this) || this;
+    _this.closed = false;
+    _this.currentObservers = null;
+    _this.observers = [];
+    _this.isStopped = false;
+    _this.hasError = false;
+    _this.thrownError = null;
+    return _this;
+  }
+  Subject2.prototype.lift = function(operator) {
+    var subject = new AnonymousSubject(this, this);
+    subject.operator = operator;
+    return subject;
+  };
+  Subject2.prototype._throwIfClosed = function() {
+    if (this.closed) {
+      throw new ObjectUnsubscribedError();
+    }
+  };
+  Subject2.prototype.next = function(value) {
+    var _this = this;
+    errorContext(function() {
+      var e_1, _a2;
+      _this._throwIfClosed();
+      if (!_this.isStopped) {
+        if (!_this.currentObservers) {
+          _this.currentObservers = Array.from(_this.observers);
+        }
+        try {
+          for (var _b = __values2(_this.currentObservers), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var observer = _c.value;
+            observer.next(value);
+          }
+        } catch (e_1_1) {
+          e_1 = { error: e_1_1 };
+        } finally {
+          try {
+            if (_c && !_c.done && (_a2 = _b.return))
+              _a2.call(_b);
+          } finally {
+            if (e_1)
+              throw e_1.error;
+          }
+        }
+      }
+    });
+  };
+  Subject2.prototype.error = function(err) {
+    var _this = this;
+    errorContext(function() {
+      _this._throwIfClosed();
+      if (!_this.isStopped) {
+        _this.hasError = _this.isStopped = true;
+        _this.thrownError = err;
+        var observers = _this.observers;
+        while (observers.length) {
+          observers.shift().error(err);
+        }
+      }
+    });
+  };
+  Subject2.prototype.complete = function() {
+    var _this = this;
+    errorContext(function() {
+      _this._throwIfClosed();
+      if (!_this.isStopped) {
+        _this.isStopped = true;
+        var observers = _this.observers;
+        while (observers.length) {
+          observers.shift().complete();
+        }
+      }
+    });
+  };
+  Subject2.prototype.unsubscribe = function() {
+    this.isStopped = this.closed = true;
+    this.observers = this.currentObservers = null;
+  };
+  Object.defineProperty(Subject2.prototype, "observed", {
+    get: function() {
+      var _a2;
+      return ((_a2 = this.observers) === null || _a2 === void 0 ? void 0 : _a2.length) > 0;
+    },
+    enumerable: false,
+    configurable: true
+  });
+  Subject2.prototype._trySubscribe = function(subscriber) {
+    this._throwIfClosed();
+    return _super.prototype._trySubscribe.call(this, subscriber);
+  };
+  Subject2.prototype._subscribe = function(subscriber) {
+    this._throwIfClosed();
+    this._checkFinalizedStatuses(subscriber);
+    return this._innerSubscribe(subscriber);
+  };
+  Subject2.prototype._innerSubscribe = function(subscriber) {
+    var _this = this;
+    var _a2 = this, hasError = _a2.hasError, isStopped = _a2.isStopped, observers = _a2.observers;
+    if (hasError || isStopped) {
+      return EMPTY_SUBSCRIPTION;
+    }
+    this.currentObservers = null;
+    observers.push(subscriber);
+    return new Subscription(function() {
+      _this.currentObservers = null;
+      arrRemove(observers, subscriber);
+    });
+  };
+  Subject2.prototype._checkFinalizedStatuses = function(subscriber) {
+    var _a2 = this, hasError = _a2.hasError, thrownError = _a2.thrownError, isStopped = _a2.isStopped;
+    if (hasError) {
+      subscriber.error(thrownError);
+    } else if (isStopped) {
+      subscriber.complete();
+    }
+  };
+  Subject2.prototype.asObservable = function() {
+    var observable2 = new Observable();
+    observable2.source = this;
+    return observable2;
+  };
+  Subject2.create = function(destination, source) {
+    return new AnonymousSubject(destination, source);
+  };
+  return Subject2;
+}(Observable);
+var AnonymousSubject = function(_super) {
+  __extends3(AnonymousSubject2, _super);
+  function AnonymousSubject2(destination, source) {
+    var _this = _super.call(this) || this;
+    _this.destination = destination;
+    _this.source = source;
+    return _this;
+  }
+  AnonymousSubject2.prototype.next = function(value) {
+    var _a2, _b;
+    (_b = (_a2 = this.destination) === null || _a2 === void 0 ? void 0 : _a2.next) === null || _b === void 0 ? void 0 : _b.call(_a2, value);
+  };
+  AnonymousSubject2.prototype.error = function(err) {
+    var _a2, _b;
+    (_b = (_a2 = this.destination) === null || _a2 === void 0 ? void 0 : _a2.error) === null || _b === void 0 ? void 0 : _b.call(_a2, err);
+  };
+  AnonymousSubject2.prototype.complete = function() {
+    var _a2, _b;
+    (_b = (_a2 = this.destination) === null || _a2 === void 0 ? void 0 : _a2.complete) === null || _b === void 0 ? void 0 : _b.call(_a2);
+  };
+  AnonymousSubject2.prototype._subscribe = function(subscriber) {
+    var _a2, _b;
+    return (_b = (_a2 = this.source) === null || _a2 === void 0 ? void 0 : _a2.subscribe(subscriber)) !== null && _b !== void 0 ? _b : EMPTY_SUBSCRIPTION;
+  };
+  return AnonymousSubject2;
+}(Subject);
+
+// node_modules/rxjs/dist/esm5/internal/BehaviorSubject.js
+import { __extends as __extends4 } from "tslib";
+var BehaviorSubject = function(_super) {
+  __extends4(BehaviorSubject2, _super);
+  function BehaviorSubject2(_value) {
+    var _this = _super.call(this) || this;
+    _this._value = _value;
+    return _this;
+  }
+  Object.defineProperty(BehaviorSubject2.prototype, "value", {
+    get: function() {
+      return this.getValue();
+    },
+    enumerable: false,
+    configurable: true
+  });
+  BehaviorSubject2.prototype._subscribe = function(subscriber) {
+    var subscription = _super.prototype._subscribe.call(this, subscriber);
+    !subscription.closed && subscriber.next(this._value);
+    return subscription;
+  };
+  BehaviorSubject2.prototype.getValue = function() {
+    var _a2 = this, hasError = _a2.hasError, thrownError = _a2.thrownError, _value = _a2._value;
+    if (hasError) {
+      throw thrownError;
+    }
+    this._throwIfClosed();
+    return _value;
+  };
+  BehaviorSubject2.prototype.next = function(value) {
+    _super.prototype.next.call(this, this._value = value);
+  };
+  return BehaviorSubject2;
+}(Subject);
+
+// node_modules/rxjs/dist/esm5/internal/operators/map.js
+function map(project, thisArg) {
+  return operate(function(source, subscriber) {
+    var index = 0;
+    source.subscribe(createOperatorSubscriber(subscriber, function(value) {
+      subscriber.next(project.call(thisArg, value, index++));
+    }));
+  });
+}
+
+// src/hooks/use-rich-errors.ts
 var $richError = new BehaviorSubject(null);
 var attachRichErrorsInterceptor = (apiClient, i18n3) => apiClient.interceptors.response.use(void 0, (error) => {
   if (i18n3.exists(`errors.${error?.response?.data?.message}`) && !error?.config?.url.includes("gas-estimate")) {
@@ -9635,7 +10471,7 @@ function useConnectModal() {
     closeConnectModal
   };
 }
-var noop = () => {
+var noop2 = () => {
 };
 function ConnectButtonRenderer({
   children
@@ -9701,9 +10537,9 @@ function ConnectButtonRenderer({
     chainModalOpen,
     connectModalOpen,
     mounted: isMounted(),
-    openAccountModal: openAccountModal != null ? openAccountModal : noop,
-    openChainModal: openChainModal != null ? openChainModal : noop,
-    openConnectModal: openConnectModal != null ? openConnectModal : noop
+    openAccountModal: openAccountModal != null ? openAccountModal : noop2,
+    openChainModal: openChainModal != null ? openChainModal : noop2,
+    openConnectModal: openConnectModal != null ? openConnectModal : noop2
   }));
 }
 ConnectButtonRenderer.displayName = "ConnectButton.Custom";
@@ -10848,8 +11684,8 @@ function createInjectedConnector(provider) {
         provider
       })
     } : {};
-    return createConnector4((config2) => ({
-      ...injected2(injectedConfig)(config2),
+    return createConnector4((config3) => ({
+      ...injected2(injectedConfig)(config3),
       ...walletDetails
     }));
   };
@@ -10872,20 +11708,20 @@ var getOrCreateWalletConnectInstance = ({
   walletConnectParameters,
   rkDetailsShowQrModal
 }) => {
-  let config2 = {
+  let config3 = {
     ...walletConnectParameters ? walletConnectParameters : {},
     projectId,
     showQrModal: false
   };
   if (rkDetailsShowQrModal) {
-    config2 = { ...config2, showQrModal: true };
+    config3 = { ...config3, showQrModal: true };
   }
-  const serializedConfig = JSON.stringify(config2);
+  const serializedConfig = JSON.stringify(config3);
   const sharedWalletConnector = walletConnectInstances.get(serializedConfig);
   if (sharedWalletConnector) {
     return sharedWalletConnector;
   }
-  const newWalletConnectInstance = walletConnect2(config2);
+  const newWalletConnectInstance = walletConnect2(config3);
   walletConnectInstances.set(serializedConfig, newWalletConnectInstance);
   return newWalletConnectInstance;
 };
@@ -10894,12 +11730,12 @@ function createWalletConnectConnector({
   walletDetails,
   walletConnectParameters
 }) {
-  return createConnector5((config2) => ({
+  return createConnector5((config3) => ({
     ...getOrCreateWalletConnectInstance({
       projectId,
       walletConnectParameters,
       rkDetailsShowQrModal: walletDetails.rkDetails.showQrModal
-    })(config2),
+    })(config3),
     ...walletDetails
   }));
 }
@@ -11257,12 +12093,12 @@ var coinbaseWallet = ({
         }
       }
     },
-    createConnector: (walletDetails) => createConnector6((config2) => ({
+    createConnector: (walletDetails) => createConnector6((config3) => ({
       ...coinbaseWagmiWallet2({
         appName,
         appLogoUrl: appIcon,
         headlessMode: true
-      })(config2),
+      })(config3),
       ...walletDetails
     }))
   };
@@ -42968,7 +43804,6 @@ var notify3 = (key) => {
 
 // src/providers/cosmos/cosmos-connector.ts
 import EventEmitter from "eventemitter3";
-import { BehaviorSubject as BehaviorSubject2 } from "rxjs";
 var wallets = [
   ...keplrWallets,
   ...leapWallets,
@@ -43008,9 +43843,9 @@ var createCosmosConnector = ({
     qrCode: {
       getUri: (uri) => uri
     },
-    createConnector: (walletDetailsParams) => createConnector7((config2) => {
+    createConnector: (walletDetailsParams) => createConnector7((config3) => {
       const provider = new EventEmitter();
-      const $filteredChains = new BehaviorSubject2(cosmosWagmiChains);
+      const $filteredChains = new BehaviorSubject(cosmosWagmiChains);
       let chainWallet = new Promise((res, rej) => {
         let retryTimes = 0;
         const check = async () => {
@@ -43033,7 +43868,7 @@ var createCosmosConnector = ({
         check();
       });
       const connect = async () => {
-        config2.emitter.emit("message", { type: "connecting" });
+        config3.emitter.emit("message", { type: "connecting" });
         const cw = await chainWallet;
         if (cw.address && cw.chainId) {
           if (cw.walletInfo.mode === "wallet-connect") {
@@ -43076,7 +43911,7 @@ var createCosmosConnector = ({
         });
       };
       const switchChain = async ({ chainId }) => {
-        const wagmiChain = config2.chains.find((c) => c.id === chainId);
+        const wagmiChain = config3.chains.find((c) => c.id === chainId);
         if (!wagmiChain)
           throw new Error("Chain not found");
         const cosmosChain = wagmiChain;
@@ -43087,7 +43922,7 @@ var createCosmosConnector = ({
           throw new Error("Wallet not found");
         chainWallet = Promise.resolve(newCw);
         await connect();
-        const chain = config2.chains.find((c) => c.id === chainId);
+        const chain = config3.chains.find((c) => c.id === chainId);
         if (!chain)
           throw new Error("Chain not found");
         onChainChanged(chainId.toString());
@@ -43096,20 +43931,20 @@ var createCosmosConnector = ({
       };
       const onAccountsChanged = (accounts) => {
         if (accounts.length === 0) {
-          config2.emitter.emit("disconnect");
+          config3.emitter.emit("disconnect");
         } else {
-          config2.emitter.emit("change", {
+          config3.emitter.emit("change", {
             accounts
           });
         }
       };
       const onChainChanged = (chainId) => {
-        config2.emitter.emit("change", {
+        config3.emitter.emit("change", {
           chainId
         });
       };
       const onDisconnect = () => {
-        config2.emitter.emit("disconnect");
+        config3.emitter.emit("disconnect");
       };
       const getAccounts = async () => {
         return [(await chainWallet).address];
@@ -43557,7 +44392,7 @@ function getNetworkInfoByTronWeb(tronWeb) {
 var TronLinkAdapterName = "TronLink";
 var TronLinkAdapter = class extends Adapter {
   // record if first connect event has emitted or not
-  constructor(config2 = {}) {
+  constructor(config3 = {}) {
     super();
     this.name = TronLinkAdapterName;
     this.url = "https://www.tronlink.org/";
@@ -43673,7 +44508,7 @@ var TronLinkAdapter = class extends Adapter {
       this.setState(state);
     };
     this.checkReadyInterval = null;
-    const { checkTimeout = 30 * 1e3, dappIcon = "", dappName = "", openUrlWhenWalletNotFound = true, openTronLinkAppOnMobile = true } = config2;
+    const { checkTimeout = 30 * 1e3, dappIcon = "", dappName = "", openUrlWhenWalletNotFound = true, openTronLinkAppOnMobile = true } = config3;
     if (typeof checkTimeout !== "number") {
       throw new Error("[TronLinkAdapter] config.checkTimeout should be a number");
     }
@@ -44072,10 +44907,10 @@ var getConnectParams = (chainId, pairingTopic) => ({
   pairingTopic
 });
 var WalletConnectWallet2 = class {
-  constructor(config2) {
-    this._options = config2.options;
-    this._network = config2.network;
-    this._web3ModalConfig = config2.web3ModalConfig || {};
+  constructor(config3) {
+    this._options = config3.options;
+    this._network = config3.network;
+    this._web3ModalConfig = config3.web3ModalConfig || {};
     this.web3Modal = new Web3Modal({
       ...this._web3ModalConfig,
       projectId: this._options.projectId,
@@ -44225,7 +45060,7 @@ var __awaiter3 = function(thisArg, _arguments, P2, generator) {
 var WalletConnectWalletName = "WalletConnect";
 var NETWORK = Object.keys(ChainNetwork);
 var WalletConnectAdapter = class extends Adapter {
-  constructor(config2) {
+  constructor(config3) {
     super();
     this.name = WalletConnectWalletName;
     this.url = "https://walletconnect.org";
@@ -44243,21 +45078,21 @@ var WalletConnectAdapter = class extends Adapter {
         this.emit("stateChanged", this._state);
       }
     };
-    config2 = Object.assign({}, config2);
-    if (!config2 || typeof config2 !== "object") {
+    config3 = Object.assign({}, config3);
+    if (!config3 || typeof config3 !== "object") {
       throw new Error(`[WalletconnectAdapter] config is required.`);
     }
-    if (!NETWORK.includes(config2.network)) {
+    if (!NETWORK.includes(config3.network)) {
       console.error(`[WalletconnectAdapter] config.network must be one of ${NETWORK.join()}. Use Nile network instead.`);
-      config2.network = "Nile";
+      config3.network = "Nile";
     }
-    if (!config2.options) {
+    if (!config3.options) {
       throw new Error(`[WalletconnectAdapter] config.options is required.`);
     }
     this._connecting = false;
     this._wallet = null;
     this._address = null;
-    this._config = config2;
+    this._config = config3;
   }
   get address() {
     return this._address;
@@ -44819,7 +45654,7 @@ var __awaiter4 = function(thisArg, _arguments, P2, generator) {
 };
 var BitgetWalletAdapterName = m === null || m === void 0 ? void 0 : m.name;
 var BitKeepAdapter = class extends Adapter {
-  constructor(config2 = {}) {
+  constructor(config3 = {}) {
     var _a2;
     super();
     this.name = BitgetWalletAdapterName;
@@ -44849,7 +45684,7 @@ var BitKeepAdapter = class extends Adapter {
       this.setAddress(address);
       this.setState(state);
     });
-    const { checkTimeout = 2 * 1e3, openUrlWhenWalletNotFound = true, openAppWithDeeplink = true } = config2;
+    const { checkTimeout = 2 * 1e3, openUrlWhenWalletNotFound = true, openAppWithDeeplink = true } = config3;
     if (typeof checkTimeout !== "number") {
       throw new Error("[BitKeepAdapter] config.checkTimeout should be a number");
     }
@@ -45426,7 +46261,7 @@ var log = (type, message, data) => {
     obj.data = data;
   dispatch(obj);
 };
-var trace = ({ type, message, data, context }) => {
+var trace = ({ type, message, data, context: context2 }) => {
   const obj = {
     type,
     id: String(++id2),
@@ -45436,14 +46271,14 @@ var trace = ({ type, message, data, context }) => {
     obj.message = message;
   if (data)
     obj.data = data;
-  if (context)
-    obj.context = context;
+  if (context2)
+    obj.context = context2;
   dispatch(obj);
 };
 var LocalTracer = class _LocalTracer {
-  constructor(type, context) {
+  constructor(type, context2) {
     this.type = type;
-    this.context = context;
+    this.context = context2;
   }
   trace(message, data) {
     trace({
@@ -45456,8 +46291,8 @@ var LocalTracer = class _LocalTracer {
   getContext() {
     return this.context;
   }
-  setContext(context) {
-    this.context = context;
+  setContext(context2) {
+    this.context = context2;
   }
   updateContext(contextToAdd) {
     this.context = Object.assign(Object.assign({}, this.context), contextToAdd);
@@ -45485,8 +46320,8 @@ var LocalTracer = class _LocalTracer {
    *
    * @param context A TraceContext, that can undefined to reset the context
    */
-  withContext(context) {
-    return new _LocalTracer(this.type, context);
+  withContext(context2) {
+    return new _LocalTracer(this.type, context2);
   }
   /**
    * Create a new instance of the LocalTracer with an updated `context`,
@@ -45552,7 +46387,7 @@ var __awaiter5 = function(thisArg, _arguments, P2, generator) {
 };
 var DEFAULT_LOG_TYPE = "transport";
 var Transport = class {
-  constructor({ context, logType } = {}) {
+  constructor({ context: context2, logType } = {}) {
     this.exchangeTimeout = 3e4;
     this.unresponsiveTimeout = 15e3;
     this.deviceModel = null;
@@ -45577,7 +46412,7 @@ var Transport = class {
       return response;
     });
     this._appAPIlock = null;
-    this.tracer = new LocalTracer(logType !== null && logType !== void 0 ? logType : DEFAULT_LOG_TYPE, context);
+    this.tracer = new LocalTracer(logType !== null && logType !== void 0 ? logType : DEFAULT_LOG_TYPE, context2);
   }
   /**
    * Send data to the device using a low level API.
@@ -45792,8 +46627,8 @@ var Transport = class {
    *
    * @param context A TraceContext, that can undefined to reset the context
    */
-  setTraceContext(context) {
-    this.tracer = this.tracer.withContext(context);
+  setTraceContext(context2) {
+    this.tracer = this.tracer.withContext(context2);
   }
   /**
    * Updates the context used by the logging/tracing mechanism
@@ -45957,7 +46792,7 @@ var id3;
 
 // node_modules/@ledgerhq/hw-transport-webhid/lib-es/TransportWebHID.js
 var import_errors3 = __toESM(require_lib());
-var __extends = /* @__PURE__ */ function() {
+var __extends5 = /* @__PURE__ */ function() {
   var extendStatics = function(d, b2) {
     extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b3) {
       d2.__proto__ = b3;
@@ -46081,7 +46916,7 @@ var __generator = function(thisArg, body) {
     return { value: op[0] ? op[1] : void 0, done: true };
   }
 };
-var __read = function(o, n) {
+var __read3 = function(o, n) {
   var m2 = typeof Symbol === "function" && o[Symbol.iterator];
   if (!m2)
     return o;
@@ -46172,7 +47007,7 @@ function getFirstLedgerDevice() {
 var TransportWebHID = (
   /** @class */
   function(_super) {
-    __extends(TransportWebHID2, _super);
+    __extends5(TransportWebHID2, _super);
     function TransportWebHID2(device) {
       var _this = _super.call(this) || this;
       _this.channel = Math.floor(Math.random() * 65535);
@@ -46272,7 +47107,7 @@ var TransportWebHID = (
             case 0:
               return [4, requestLedgerDevices()];
             case 1:
-              _a2 = __read.apply(void 0, [_b.sent(), 1]), device = _a2[0];
+              _a2 = __read3.apply(void 0, [_b.sent(), 1]), device = _a2[0];
               return [2, TransportWebHID2.open(device)];
           }
         });
@@ -46922,7 +47757,7 @@ function wait(timeout) {
     });
   });
 }
-function isFunction(fn11) {
+function isFunction2(fn11) {
   return typeof fn11 === "function";
 }
 var defaultSelectAccount = function({ accounts, ledgerUtils }) {
@@ -46941,7 +47776,7 @@ var defaultSelectAccount = function({ accounts, ledgerUtils }) {
   });
 };
 var LedgerWallet = class {
-  constructor(config2 = {}) {
+  constructor(config3 = {}) {
     this.app = null;
     this.transport = null;
     this.fetchState = "Initial";
@@ -46985,16 +47820,16 @@ var LedgerWallet = class {
       }
     });
     this.accounts = [];
-    const { accountNumber = 1 } = config2;
+    const { accountNumber = 1 } = config3;
     ["beforeConnect", "selectAccount", "getDerivationPath"].forEach((func) => {
-      if (config2[func] && !isFunction(config2[func])) {
+      if (config3[func] && !isFunction2(config3[func])) {
         throw new Error(`[Ledger]: ${func} must be a function!`);
       }
     });
     if (accountNumber && !Number.isInteger(+accountNumber)) {
       throw new Error("[Ledger]: accountNumber must be an integer!");
     }
-    this.config = Object.assign(Object.assign({}, config2), { accountNumber });
+    this.config = Object.assign(Object.assign({}, config3), { accountNumber });
   }
   get address() {
     return this._address;
@@ -47165,7 +48000,7 @@ var __awaiter9 = function(thisArg, _arguments, P2, generator) {
 var isSupportedLedger = () => !!(globalThis.navigator && globalThis.navigator.hid);
 var LedgerAdapterName = "Ledger";
 var LedgerAdapter = class extends Adapter {
-  constructor(config2 = {}) {
+  constructor(config3 = {}) {
     super();
     this.name = LedgerAdapterName;
     this.url = "https://www.ledger.com/";
@@ -47174,8 +48009,8 @@ var LedgerAdapter = class extends Adapter {
     this._state = AdapterState.NotFound;
     this._connecting = false;
     this._address = null;
-    this.config = config2;
-    this._wallet = new LedgerWallet(config2);
+    this.config = config3;
+    this._wallet = new LedgerWallet(config3);
     if (isSupportedLedger()) {
       this._readyState = WalletReadyState.Found;
       this._state = AdapterState.Disconnect;
@@ -47295,7 +48130,6 @@ var bitget_default = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAJAAAACQCAMA
 var ledger = "data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIyOCIgaGVpZ2h0PSIyOCIgZmlsbD0ibm9uZSI+PHBhdGggZmlsbD0iIzAwMCIgZD0iTTAgMGgyOHYyOEgweiIvPjxwYXRoIGZpbGw9IiNmZmYiIGZpbGwtcnVsZT0iZXZlbm9kZCIgZD0iTTExLjY1IDQuNEg0LjRWOWgxLjFWNS41bDYuMTUtLjA0VjQuNFptLjA1IDUuOTV2Ny4yNWg0LjZ2LTEuMWgtMy41bC0uMDQtNi4xNUgxMS43Wk00LjQgMjMuNmg3LjI1di0xLjA2TDUuNSAyMi41VjE5SDQuNHY0LjZaTTE2LjM1IDQuNGg3LjI1VjloLTEuMVY1LjVsLTYuMTUtLjA0VjQuNFptNy4yNSAxOS4yaC03LjI1di0xLjA2bDYuMTUtLjA0VjE5aDEuMXY0LjZaIiBjbGlwLXJ1bGU9ImV2ZW5vZGQiLz48L3N2Zz4=";
 
 // src/providers/misc/tron-connector.ts
-import { BehaviorSubject as BehaviorSubject3 } from "rxjs";
 var configMeta2 = {
   tronLink: {
     id: "tronLink",
@@ -47323,14 +48157,14 @@ var createTronConnector = ({
   adapter,
   metaConfig,
   walletDetailsParams
-}) => createConnector8((config2) => ({
+}) => createConnector8((config3) => ({
   ...walletDetailsParams,
   id: configMeta2[metaConfig].id,
   name: configMeta2[metaConfig].name,
   type: configMeta2[metaConfig].type,
   signTransaction: adapter.signTransaction.bind(adapter),
   connect: async () => {
-    config2.emitter.emit("message", { type: "connecting" });
+    config3.emitter.emit("message", { type: "connecting" });
     await adapter.connect();
     setStorageItem("sk-widget@1//shimDisconnect/tron", true);
     return {
@@ -47354,19 +48188,19 @@ var createTronConnector = ({
   isAuthorized: async () => getStorageItem("sk-widget@1//shimDisconnect/tron").map((val) => !!(val && adapter.connected && adapter.address)).orDefault(false),
   onAccountsChanged: (accounts) => {
     if (accounts.length === 0) {
-      config2.emitter.emit("disconnect");
+      config3.emitter.emit("disconnect");
     } else {
-      config2.emitter.emit("change", { accounts });
+      config3.emitter.emit("change", { accounts });
     }
   },
   onChainChanged: (chainId) => {
-    config2.emitter.emit("change", { chainId: normalizeChainId(chainId) });
+    config3.emitter.emit("change", { chainId: normalizeChainId(chainId) });
   },
   onDisconnect: () => {
-    config2.emitter.emit("disconnect");
+    config3.emitter.emit("disconnect");
   },
   getProvider: async () => ({}),
-  $filteredChains: new BehaviorSubject3([tron]).asObservable()
+  $filteredChains: new BehaviorSubject([tron]).asObservable()
 }));
 var tronConnector = {
   groupName: "Tron",
@@ -49850,7 +50684,6 @@ var getLedgerCurrencies = (walletAPIClient) => EitherAsync12(() => walletAPIClie
 });
 
 // src/providers/ledger/ledger-connector.ts
-import { BehaviorSubject as BehaviorSubject4, map } from "rxjs";
 var configMeta3 = {
   id: "ledgerLive",
   name: "Ledger Live",
@@ -49861,14 +50694,14 @@ var createLedgerLiveConnector = ({
   walletDetailsParams,
   enabledChainsMap,
   queryParams
-}) => createConnector9((config2) => {
+}) => createConnector9((config3) => {
   const noAccountPlaceholder = "N/A";
-  const $filteredChains = new BehaviorSubject4([]);
-  const $disabledChains = new BehaviorSubject4([]);
-  const $currentAccount = new BehaviorSubject4(void 0);
+  const $filteredChains = new BehaviorSubject([]);
+  const $disabledChains = new BehaviorSubject([]);
+  const $currentAccount = new BehaviorSubject(void 0);
   const $currentAccountId = $currentAccount.pipe(map((v) => v?.id));
   let ledgerAccounts = [];
-  const $accountsOnCurrentChain = new BehaviorSubject4([]);
+  const $accountsOnCurrentChain = new BehaviorSubject([]);
   let currentChain = null;
   let filteredSkSupportedChainsToCurrencyIdMap = null;
   let filteredSkSupportedChainsValues = null;
@@ -49876,7 +50709,7 @@ var createLedgerLiveConnector = ({
   transport.connect();
   const walletApiClient = new WalletAPIClient(transport);
   const connect = async () => {
-    config2.emitter.emit("message", { type: "connecting" });
+    config3.emitter.emit("message", { type: "connecting" });
     const ledgerCurrencies = (await getLedgerCurrencies(walletApiClient)).unsafeCoerce();
     const accounts = (await EitherAsync13(() => walletApiClient.account.list()).mapLeft((e) => {
       console.log(e);
@@ -49969,16 +50802,16 @@ var createLedgerLiveConnector = ({
   );
   const onAccountsChanged = (accounts) => {
     if (accounts.length === 0) {
-      config2.emitter.emit("disconnect");
+      config3.emitter.emit("disconnect");
     } else {
-      config2.emitter.emit("change", { accounts });
+      config3.emitter.emit("change", { accounts });
     }
   };
   const onChainChanged = (chainId) => {
-    config2.emitter.emit("change", { chainId: normalizeChainId2(chainId) });
+    config3.emitter.emit("change", { chainId: normalizeChainId2(chainId) });
   };
   const onDisconnect = () => {
-    config2.emitter.emit("disconnect");
+    config3.emitter.emit("disconnect");
   };
   const getProvider = async () => ({});
   const isAuthorized = async () => isLedgerDappBrowserProvider();
@@ -50212,7 +51045,6 @@ import {
   createConnector as createConnector10,
   normalizeChainId as normalizeChainId3
 } from "wagmi";
-import { BehaviorSubject as BehaviorSubject5 } from "rxjs";
 var configMeta4 = {
   id: "externalProviderConnector",
   name: "External Provider",
@@ -50227,8 +51059,8 @@ var externalProviderConnector = (variant, transactionGetTransactionStatusByNetwo
       name: configMeta4.name,
       iconUrl: getSKIcon("sk-icon_320x320.png"),
       iconBackground: "#fff",
-      createConnector: () => createConnector10((config2) => {
-        const $filteredChains = new BehaviorSubject5([]);
+      createConnector: () => createConnector10((config3) => {
+        const $filteredChains = new BehaviorSubject([]);
         const provider = new ExternalProvider(
           variant,
           transactionGetTransactionStatusByNetworkAndHash
@@ -50236,13 +51068,13 @@ var externalProviderConnector = (variant, transactionGetTransactionStatusByNetwo
         const getAccounts = async () => (await provider.getAccount().map((val) => [val])).unsafeCoerce();
         const getChainId = async () => (await provider.getChainId()).unsafeCoerce();
         const connect = async () => {
-          config2.emitter.emit("message", { type: "connecting" });
+          config3.emitter.emit("message", { type: "connecting" });
           const [accounts, chainId] = await Promise.all([
             getAccounts(),
             getChainId()
           ]);
           $filteredChains.next(
-            config2.chains.filter((c) => c.id === chainId)
+            config3.chains.filter((c) => c.id === chainId)
           );
           return { accounts, chainId };
         };
@@ -50250,7 +51082,7 @@ var externalProviderConnector = (variant, transactionGetTransactionStatusByNetwo
           return (await EitherAsync15.liftEither(
             List3.find(
               (c) => c.id === chainId,
-              config2.chains
+              config3.chains
             ).toEither(new Error("Chain not found"))
           ).chain(
             (chain) => provider.switchChain({ chainId: `0x${chainId.toString(16)}` }).map(() => chain)
@@ -50261,10 +51093,10 @@ var externalProviderConnector = (variant, transactionGetTransactionStatusByNetwo
         const getProvider = async () => ({});
         const isAuthorized = async () => true;
         const onDisconnect = () => {
-          config2.emitter.emit("disconnect");
+          config3.emitter.emit("disconnect");
         };
         const onChainChanged = (chainId) => {
-          config2.emitter.emit("change", {
+          config3.emitter.emit("change", {
             chainId: normalizeChainId3(chainId)
           });
         };
@@ -50623,9 +51455,8 @@ import { Either as Either2, EitherAsync as EitherAsync21, Left as Left7, Maybe a
 
 // src/providers/sk-wallet/use-ledger-accounts.ts
 import { useCallback as useCallback12, useState as useState21, useSyncExternalStore as useSyncExternalStore3 } from "react";
-import { BehaviorSubject as BehaviorSubject6 } from "rxjs";
 var useLedgerAccounts = (connector) => {
-  const [subject] = useState21(() => new BehaviorSubject6([]));
+  const [subject] = useState21(() => new BehaviorSubject([]));
   const subscribe3 = useCallback12(
     (onChange) => {
       if (!connector || !isLedgerLiveConnector(connector)) {
@@ -50885,11 +51716,11 @@ var TrackingContextProvider = ({
   return /* @__PURE__ */ jsx6(TrackingContext.Provider, { value, children });
 };
 var useTracking = () => {
-  const context = useContext30(TrackingContext);
-  if (context === void 0) {
+  const context2 = useContext30(TrackingContext);
+  if (context2 === void 0) {
     throw new Error("useTracking must be used within a TrackingContext");
   }
-  return context;
+  return context2;
 };
 
 // src/hooks/tracking/use-track-event.ts
@@ -50904,12 +51735,11 @@ var isConnectorWithFilteredChains = (connector) => {
 };
 
 // src/providers/sk-wallet/use-connector-chains.ts
-import { BehaviorSubject as BehaviorSubject7 } from "rxjs";
 var useConnectorChains = ({
   wagmiConfig,
   connector
 }) => {
-  const [subject] = useState23(() => new BehaviorSubject7([]));
+  const [subject] = useState23(() => new BehaviorSubject([]));
   const subscribe3 = useCallback14(
     (onChange) => {
       if (!connector || !isConnectorWithFilteredChains(connector)) {
@@ -50937,10 +51767,9 @@ var defaultValue = [];
 
 // src/providers/sk-wallet/use-ledger-current-account-id.ts
 import { useCallback as useCallback15, useState as useState24, useSyncExternalStore as useSyncExternalStore5 } from "react";
-import { BehaviorSubject as BehaviorSubject8 } from "rxjs";
 var useLedgerCurrentAccountId = (connector) => {
   const [subject] = useState24(
-    () => new BehaviorSubject8(void 0)
+    () => new BehaviorSubject(void 0)
   );
   const subscribe3 = useCallback15(
     (onChange) => {
@@ -51304,13 +52133,13 @@ var ActionHistoryContextProvider = ({
   return /* @__PURE__ */ jsx8(ActionHistoryContext.Provider, { value, children });
 };
 var useActionHistory = () => {
-  const context = useContext33(ActionHistoryContext);
-  if (context === void 0) {
+  const context2 = useContext33(ActionHistoryContext);
+  if (context2 === void 0) {
     throw new Error(
       "useActionHistory must be used within a ActionHistoryContextProvider"
     );
   }
-  return context;
+  return context2;
 };
 var useActionHistoryData = () => useActionHistory()[0];
 var useSetActionHistoryData = () => useActionHistory()[1];
@@ -52653,8 +53482,8 @@ var useSyncElementHeight = (setCurrentHeight) => {
 // src/utils/create-state-context.ts
 import { createContext as createContext25, createElement as createElement4, useContext as useContext38, useState as useState26 } from "react";
 var createStateContext = (defaultInitialValue) => {
-  const context = createContext25(void 0);
-  const providerFactory = (props, children) => createElement4(context.Provider, props, children);
+  const context2 = createContext25(void 0);
+  const providerFactory = (props, children) => createElement4(context2.Provider, props, children);
   const StateProvider = ({
     children,
     initialValue
@@ -52665,13 +53494,13 @@ var createStateContext = (defaultInitialValue) => {
     return providerFactory({ value: state }, children);
   };
   const useStateContext = () => {
-    const state = useContext38(context);
+    const state = useContext38(context2);
     if (state == null) {
       throw new Error(`useStateContext must be used inside a StateProvider.`);
     }
     return state;
   };
-  return [useStateContext, StateProvider, context];
+  return [useStateContext, StateProvider, context2];
 };
 var create_state_context_default = createStateContext;
 
@@ -55228,13 +56057,13 @@ var ListStateContextProvider = ({ children }) => {
   return /* @__PURE__ */ jsx50(ListStateContext.Provider, { value, children });
 };
 var useListState = () => {
-  const context = useContext44(ListStateContext);
-  if (!context) {
+  const context2 = useContext44(ListStateContext);
+  if (!context2) {
     throw new Error(
       "useListStateContext must be used within a ListStateContextProvider"
     );
   }
-  return context;
+  return context2;
 };
 var useHandleListState = () => {
   const virtualListRef = useRef13(null);
@@ -55336,13 +56165,13 @@ var MountAnimationProvider = ({ children }) => {
   return /* @__PURE__ */ jsx52(MountAnimationContext.Provider, { value, children });
 };
 var useMountAnimation = () => {
-  const context = useContext46(MountAnimationContext);
-  if (!context) {
+  const context2 = useContext46(MountAnimationContext);
+  if (!context2) {
     throw new Error(
       "useMountAnimation must be used within a MountAnimationProvider"
     );
   }
-  return context;
+  return context2;
 };
 
 // src/pages/details/positions-page/positions.page.tsx
@@ -56277,11 +57106,11 @@ var DetailsContextProvider = ({ children }) => {
   return /* @__PURE__ */ jsx54(DetailsContext.Provider, { value, children });
 };
 var useDetailsContext = () => {
-  const context = useContext47(DetailsContext);
-  if (!context) {
+  const context2 = useContext47(DetailsContext);
+  if (!context2) {
     throw new Error("useDetailsContext must be used within a DetailsContext");
   }
-  return context;
+  return context2;
 };
 
 // src/components/atoms/icons/info.tsx
@@ -59028,7 +59857,7 @@ var createReducer = function createReducer2(definition) {
       var event = typeof sendable === "string" ? {
         type: sendable
       } : sendable;
-      var context = machineState.context;
+      var context2 = machineState.context;
       var stateNode = R2.get(definition.states, machineState.value);
       var resolvedTransition = (_R$get = R2.get(R2.fromMaybe(stateNode.on), event.type)) != null ? _R$get : R2.get(R2.fromMaybe(definition.on), event.type);
       if (!resolvedTransition) {
@@ -59041,14 +59870,14 @@ var createReducer = function createReducer2(definition) {
         if (resolvedTransition.guard === void 0)
           return [resolvedTransition.target];
         if (resolvedTransition.guard({
-          context,
+          context: context2,
           event
         }))
           return [resolvedTransition.target];
         return [resolvedTransition.target, true];
       }(), nextStateValue = _ref[0], _ref$ = _ref[1], didGuardDeny = _ref$ === void 0 ? false : _ref$;
       if (didGuardDeny) {
-        log2('Transition from "' + machineState.value + '" to "' + nextStateValue + '" denied by guard', ["Event", event], ["Context", context]);
+        log2('Transition from "' + machineState.value + '" to "' + nextStateValue + '" denied by guard', ["Event", event], ["Context", context2]);
         return machineState;
       }
       log2('Transition from "' + machineState.value + '" to "' + nextStateValue + '"', ["Event", event]);
@@ -59056,7 +59885,7 @@ var createReducer = function createReducer2(definition) {
       var nextEvents = R2.keys(R2.concat(R2.fromMaybe(resolvedStateNode.on), R2.fromMaybe(definition.on)));
       return {
         value: nextStateValue,
-        context,
+        context: context2,
         event,
         nextEvents,
         nextEventsT: nextEvents
@@ -59165,10 +59994,10 @@ var useStepsMachine = (session) => {
           BROADCAST_SUCCESS: "txCheckLoading",
           DONE: "done"
         },
-        effect: ({ context, send, setContext }) => {
+        effect: ({ context: context2, send, setContext }) => {
           EitherAsync34.liftEither(
             Maybe46.fromNullable(
-              context.txStates[context.currentTxMeta?.idx].tx
+              context2.txStates[context2.currentTxMeta?.idx].tx
             ).toEither(new Error("missing tx"))
           ).chain((tx) => {
             if (shouldMultiSend) {
@@ -59249,7 +60078,7 @@ var useStepsMachine = (session) => {
                 ).map(() => ({ type: "p2pNode" }));
               }
               return EitherAsync34.liftEither(
-                Right16(context.txStates[context.currentTxMeta?.idx].tx)
+                Right16(context2.txStates[context2.currentTxMeta?.idx].tx)
               ).chain(
                 (tx2) => getAverageGasMode({
                   network: tx2.network,
@@ -59279,7 +60108,7 @@ var useStepsMachine = (session) => {
                   () => trackEvent("txSigned", {
                     txId: constructedTx.id,
                     network: constructedTx.network,
-                    yieldId: context.yieldId
+                    yieldId: context2.yieldId
                   })
                 );
               }).map((val) => ({ type: "regular", data: val }));
@@ -59333,10 +60162,10 @@ var useStepsMachine = (session) => {
           BROADCAST_SUCCESS: "txCheckLoading",
           BROADCAST_ERROR: "broadcastError"
         },
-        effect: ({ send, context, setContext }) => {
+        effect: ({ send, context: context2, setContext }) => {
           EitherAsync34.liftEither(
             Maybe46.fromNullable(
-              context.txStates[context.currentTxMeta?.idx]
+              context2.txStates[context2.currentTxMeta?.idx]
             ).toEither(new Error("missing tx"))
           ).chain((currentTx) => {
             if (currentTx.meta.broadcasted) {
@@ -59348,7 +60177,7 @@ var useStepsMachine = (session) => {
                 trackEvent("txSubmitted", {
                   txId: currentTx.tx.id,
                   network: currentTx.tx.network,
-                  yieldId: context.yieldId
+                  yieldId: context2.yieldId
                 });
               });
             } else {
@@ -59362,7 +60191,7 @@ var useStepsMachine = (session) => {
                 trackEvent("txSubmitted", {
                   txId: currentTx.tx.id,
                   network: currentTx.tx.network,
-                  yieldId: context.yieldId
+                  yieldId: context2.yieldId
                 });
               });
             }
@@ -59413,10 +60242,10 @@ var useStepsMachine = (session) => {
           TX_CHECK_ERROR: "txCheckError",
           TX_CHECK_RETRY: "txCheckRetry"
         },
-        effect: ({ send, context, setContext }) => {
+        effect: ({ send, context: context2, setContext }) => {
           EitherAsync34.liftEither(
             Maybe46.fromNullable(
-              context.txStates[context.currentTxMeta?.idx]
+              context2.txStates[context2.currentTxMeta?.idx]
             ).toEither(new Error("missing tx"))
           ).chain(
             (currentTx) => withRequestErrorRetry({
@@ -59448,7 +60277,7 @@ var useStepsMachine = (session) => {
               if (l instanceof SignError) {
                 trackEvent("txNotConfirmed", {
                   txId: l.txId,
-                  yieldId: context.yieldId
+                  yieldId: context2.yieldId
                 });
               }
               setContext((ctx) => ({
@@ -59468,8 +60297,8 @@ var useStepsMachine = (session) => {
             },
             Right: (v) => {
               if (v.isConfirmed) {
-                const newTxStates = context.txStates.map(
-                  (val, i) => i === context.currentTxMeta?.idx ? {
+                const newTxStates = context2.txStates.map(
+                  (val, i) => i === context2.currentTxMeta?.idx ? {
                     ...val,
                     meta: {
                       ...val.meta,
@@ -60124,20 +60953,20 @@ import { jsx as jsx91 } from "react/jsx-runtime";
 var queryKey7 = ["wagmi-config", "on-mount"];
 var WagmiConfigProvider = ({ children }) => {
   const wagmiConfig = useWagmiConfig();
-  const config2 = wagmiConfig.data?.wagmiConfig;
+  const config3 = wagmiConfig.data?.wagmiConfig;
   useQuery12({
     queryKey: queryKey7,
     staleTime: Infinity,
-    enabled: !!config2,
+    enabled: !!config3,
     queryFn: async () => {
-      if (config2) {
-        const { onMount } = hydrate(config2, { reconnectOnMount: true });
+      if (config3) {
+        const { onMount } = hydrate(config3, { reconnectOnMount: true });
         await EitherAsync35(onMount);
       }
       return null;
     }
   });
-  return /* @__PURE__ */ jsx91(WagmiContext.Provider, { value: config2 ?? defaultConfig, children });
+  return /* @__PURE__ */ jsx91(WagmiContext.Provider, { value: config3 ?? defaultConfig, children });
 };
 
 // src/providers/rainbow-kit.tsx
@@ -60145,9 +60974,8 @@ import { useMemo as useMemo62 } from "react";
 
 // src/providers/sk-wallet/use-ledger-disabled-chains.ts
 import { useCallback as useCallback24, useState as useState45, useSyncExternalStore as useSyncExternalStore7 } from "react";
-import { BehaviorSubject as BehaviorSubject9 } from "rxjs";
 var useLedgerDisabledChain = (connector) => {
-  const [subject] = useState45(() => new BehaviorSubject9([]));
+  const [subject] = useState45(() => new BehaviorSubject([]));
   const subscribe3 = useCallback24(
     (onChange) => {
       if (!connector || !isLedgerLiveConnector(connector)) {
@@ -60845,10 +61673,10 @@ var useUnstakeMachine = () => {
           __UNSTAKE_SIGN_MESSAGE_SUCCESS__: "unstakeLoading",
           __UNSTAKE_SIGN_MESSAGE_ERROR__: "unstakeSignMessageError"
         },
-        effect: ({ send, context, setContext }) => {
+        effect: ({ send, context: context2, setContext }) => {
           EitherAsync37.liftEither(
             Maybe52.fromNullable(
-              context.transactionVerificationMessageDto
+              context2.transactionVerificationMessageDto
             ).toEither(new Error("Missing transaction verification message"))
           ).chain((val) => signMessage(val.message)).caseOf({
             Right(v) {
@@ -60868,17 +61696,17 @@ var useUnstakeMachine = () => {
       unstakeSignMessageError: {},
       unstakeLoading: {
         on: { __UNSTAKE_ERROR__: "unstakeError" },
-        effect: ({ context, setContext, send }) => {
+        effect: ({ context: context2, setContext, send }) => {
           EitherAsync37.liftEither(
             stakeExitRequestDto.toEither(new Error("Missing params"))
           ).chain(
             (val) => EitherAsync37(() => {
-              const stakeRequestDto = context.transactionVerificationMessageDto && context.signedMessage ? merge2(val, {
+              const stakeRequestDto = context2.transactionVerificationMessageDto && context2.signedMessage ? merge2(val, {
                 dto: {
                   args: {
                     signatureVerification: {
-                      message: context.transactionVerificationMessageDto.message,
-                      signed: context.signedMessage
+                      message: context2.transactionVerificationMessageDto.message,
+                      signed: context2.signedMessage
                     }
                   }
                 }
@@ -61145,11 +61973,11 @@ var CopyTextContext = createContext34(
   void 0
 );
 var useCopyText = () => {
-  const context = useContext49(CopyTextContext);
-  if (!context) {
+  const context2 = useContext49(CopyTextContext);
+  if (!context2) {
     throw new Error("useCopyText must be used within a CopyTextProvider");
   }
-  return context;
+  return context2;
 };
 var Provider2 = ({
   text,