@0xsquid/react-hooks 8.3.1-beta-stellar-issued-assets.1 → 8.3.1-embed-tanstack-build.0

package/dist/{index-CJQHDfLM.js → index-DOoP75Yp.js}

@@ -3,7 +3,6 @@
 var squidTypes = require('@0xsquid/squid-types');
 var viem = require('viem');
 var React = require('react');
-var reactQuery = require('@tanstack/react-query');
 var encoding = require('@cosmjs/encoding');
 var bitcoin = require('bitcoinjs-lib');
 var ecc = require('@bitcoinerlab/secp256k1');
@@ -54,6 +53,7 @@ function _interopNamespaceDefault(e) {
     return Object.freeze(n);
 }
 
+var React__namespace = /*#__PURE__*/_interopNamespaceDefault(React);
 var bitcoin__namespace = /*#__PURE__*/_interopNamespaceDefault(bitcoin);
 var ecc__namespace = /*#__PURE__*/_interopNamespaceDefault(ecc);
 
@@ -221,22 +221,3053 @@ const transactionEndStatuses = [
     ...transactionErrorStatuses,
 ];
 
-exports.TransactionErrorType = void 0;
-(function (TransactionErrorType) {
-    TransactionErrorType[TransactionErrorType["REJECTED_BY_USER"] = 0] = "REJECTED_BY_USER";
-    TransactionErrorType[TransactionErrorType["CALL_EXCEPTION"] = 1] = "CALL_EXCEPTION";
-    TransactionErrorType[TransactionErrorType["UNKNOWN"] = 2] = "UNKNOWN";
-    TransactionErrorType[TransactionErrorType["WARNING"] = 3] = "WARNING";
-})(exports.TransactionErrorType || (exports.TransactionErrorType = {}));
-exports.SquidStatusErrorType = void 0;
-(function (SquidStatusErrorType) {
-    SquidStatusErrorType["NotFoundError"] = "NotFoundError";
-})(exports.SquidStatusErrorType || (exports.SquidStatusErrorType = {}));
-class QrCodeGenerationError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = "QrCodeGenerationError";
+class Subscribable {
+  constructor() {
+    this.listeners = new Set();
+    this.subscribe = this.subscribe.bind(this);
+  }
+
+  subscribe(listener) {
+    const identity = {
+      listener
+    };
+    this.listeners.add(identity);
+    this.onSubscribe();
+    return () => {
+      this.listeners.delete(identity);
+      this.onUnsubscribe();
+    };
+  }
+
+  hasListeners() {
+    return this.listeners.size > 0;
+  }
+
+  onSubscribe() {// Do nothing
+  }
+
+  onUnsubscribe() {// Do nothing
+  }
+
+}
+
+// TYPES
+// UTILS
+const isServer = typeof window === 'undefined' || 'Deno' in window;
+function noop$1() {
+  return undefined;
+}
+function functionalUpdate(updater, input) {
+  return typeof updater === 'function' ? updater(input) : updater;
+}
+function isValidTimeout(value) {
+  return typeof value === 'number' && value >= 0 && value !== Infinity;
+}
+function difference(array1, array2) {
+  return array1.filter(x => !array2.includes(x));
+}
+function replaceAt(array, index, value) {
+  const copy = array.slice(0);
+  copy[index] = value;
+  return copy;
+}
+function timeUntilStale(updatedAt, staleTime) {
+  return Math.max(updatedAt + (staleTime || 0) - Date.now(), 0);
+}
+function parseQueryArgs(arg1, arg2, arg3) {
+  if (!isQueryKey(arg1)) {
+    return arg1;
+  }
+
+  if (typeof arg2 === 'function') {
+    return { ...arg3,
+      queryKey: arg1,
+      queryFn: arg2
+    };
+  }
+
+  return { ...arg2,
+    queryKey: arg1
+  };
+}
+function parseMutationArgs(arg1, arg2, arg3) {
+  if (isQueryKey(arg1)) {
+    if (typeof arg2 === 'function') {
+      return { ...arg3,
+        mutationKey: arg1,
+        mutationFn: arg2
+      };
+    }
+
+    return { ...arg2,
+      mutationKey: arg1
+    };
+  }
+
+  if (typeof arg1 === 'function') {
+    return { ...arg2,
+      mutationFn: arg1
+    };
+  }
+
+  return { ...arg1
+  };
+}
+function parseFilterArgs(arg1, arg2, arg3) {
+  return isQueryKey(arg1) ? [{ ...arg2,
+    queryKey: arg1
+  }, arg3] : [arg1 || {}, arg2];
+}
+function matchQuery(filters, query) {
+  const {
+    type = 'all',
+    exact,
+    fetchStatus,
+    predicate,
+    queryKey,
+    stale
+  } = filters;
+
+  if (isQueryKey(queryKey)) {
+    if (exact) {
+      if (query.queryHash !== hashQueryKeyByOptions(queryKey, query.options)) {
+        return false;
+      }
+    } else if (!partialMatchKey(query.queryKey, queryKey)) {
+      return false;
+    }
+  }
+
+  if (type !== 'all') {
+    const isActive = query.isActive();
+
+    if (type === 'active' && !isActive) {
+      return false;
+    }
+
+    if (type === 'inactive' && isActive) {
+      return false;
+    }
+  }
+
+  if (typeof stale === 'boolean' && query.isStale() !== stale) {
+    return false;
+  }
+
+  if (typeof fetchStatus !== 'undefined' && fetchStatus !== query.state.fetchStatus) {
+    return false;
+  }
+
+  if (predicate && !predicate(query)) {
+    return false;
+  }
+
+  return true;
+}
+function matchMutation(filters, mutation) {
+  const {
+    exact,
+    fetching,
+    predicate,
+    mutationKey
+  } = filters;
+
+  if (isQueryKey(mutationKey)) {
+    if (!mutation.options.mutationKey) {
+      return false;
+    }
+
+    if (exact) {
+      if (hashQueryKey(mutation.options.mutationKey) !== hashQueryKey(mutationKey)) {
+        return false;
+      }
+    } else if (!partialMatchKey(mutation.options.mutationKey, mutationKey)) {
+      return false;
+    }
+  }
+
+  if (typeof fetching === 'boolean' && mutation.state.status === 'loading' !== fetching) {
+    return false;
+  }
+
+  if (predicate && !predicate(mutation)) {
+    return false;
+  }
+
+  return true;
+}
+function hashQueryKeyByOptions(queryKey, options) {
+  const hashFn = (options == null ? void 0 : options.queryKeyHashFn) || hashQueryKey;
+  return hashFn(queryKey);
+}
+/**
+ * Default query keys hash function.
+ * Hashes the value into a stable hash.
+ */
+
+function hashQueryKey(queryKey) {
+  return JSON.stringify(queryKey, (_, val) => isPlainObject(val) ? Object.keys(val).sort().reduce((result, key) => {
+    result[key] = val[key];
+    return result;
+  }, {}) : val);
+}
+/**
+ * Checks if key `b` partially matches with key `a`.
+ */
+
+function partialMatchKey(a, b) {
+  return partialDeepEqual(a, b);
+}
+/**
+ * Checks if `b` partially matches with `a`.
+ */
+
+function partialDeepEqual(a, b) {
+  if (a === b) {
+    return true;
+  }
+
+  if (typeof a !== typeof b) {
+    return false;
+  }
+
+  if (a && b && typeof a === 'object' && typeof b === 'object') {
+    return !Object.keys(b).some(key => !partialDeepEqual(a[key], b[key]));
+  }
+
+  return false;
+}
+/**
+ * This function returns `a` if `b` is deeply equal.
+ * If not, it will replace any deeply equal children of `b` with those of `a`.
+ * This can be used for structural sharing between JSON values for example.
+ */
+
+function replaceEqualDeep(a, b) {
+  if (a === b) {
+    return a;
+  }
+
+  const array = isPlainArray(a) && isPlainArray(b);
+
+  if (array || isPlainObject(a) && isPlainObject(b)) {
+    const aSize = array ? a.length : Object.keys(a).length;
+    const bItems = array ? b : Object.keys(b);
+    const bSize = bItems.length;
+    const copy = array ? [] : {};
+    let equalItems = 0;
+
+    for (let i = 0; i < bSize; i++) {
+      const key = array ? i : bItems[i];
+      copy[key] = replaceEqualDeep(a[key], b[key]);
+
+      if (copy[key] === a[key]) {
+        equalItems++;
+      }
+    }
+
+    return aSize === bSize && equalItems === aSize ? a : copy;
+  }
+
+  return b;
+}
+/**
+ * Shallow compare objects. Only works with objects that always have the same properties.
+ */
+
+function shallowEqualObjects(a, b) {
+  if (a && !b || b && !a) {
+    return false;
+  }
+
+  for (const key in a) {
+    if (a[key] !== b[key]) {
+      return false;
+    }
+  }
+
+  return true;
+}
+function isPlainArray(value) {
+  return Array.isArray(value) && value.length === Object.keys(value).length;
+} // Copied from: https://github.com/jonschlinkert/is-plain-object
+
+function isPlainObject(o) {
+  if (!hasObjectPrototype(o)) {
+    return false;
+  } // If has modified constructor
+
+
+  const ctor = o.constructor;
+
+  if (typeof ctor === 'undefined') {
+    return true;
+  } // If has modified prototype
+
+
+  const prot = ctor.prototype;
+
+  if (!hasObjectPrototype(prot)) {
+    return false;
+  } // If constructor does not have an Object-specific method
+
+
+  if (!prot.hasOwnProperty('isPrototypeOf')) {
+    return false;
+  } // Most likely a plain Object
+
+
+  return true;
+}
+
+function hasObjectPrototype(o) {
+  return Object.prototype.toString.call(o) === '[object Object]';
+}
+
+function isQueryKey(value) {
+  return Array.isArray(value);
+}
+function sleep$1(timeout) {
+  return new Promise(resolve => {
+    setTimeout(resolve, timeout);
+  });
+}
+/**
+ * Schedules a microtask.
+ * This can be useful to schedule state updates after rendering.
+ */
+
+function scheduleMicrotask(callback) {
+  sleep$1(0).then(callback);
+}
+function getAbortController() {
+  if (typeof AbortController === 'function') {
+    return new AbortController();
+  }
+
+  return;
+}
+function replaceData(prevData, data, options) {
+  // Use prev data if an isDataEqual function is defined and returns `true`
+  if (options.isDataEqual != null && options.isDataEqual(prevData, data)) {
+    return prevData;
+  } else if (typeof options.structuralSharing === 'function') {
+    return options.structuralSharing(prevData, data);
+  } else if (options.structuralSharing !== false) {
+    // Structurally share data between prev and new data if needed
+    return replaceEqualDeep(prevData, data);
+  }
+
+  return data;
+}
+
+class FocusManager extends Subscribable {
+  constructor() {
+    super();
+
+    this.setup = onFocus => {
+      // addEventListener does not exist in React Native, but window does
+      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+      if (!isServer && window.addEventListener) {
+        const listener = () => onFocus(); // Listen to visibillitychange and focus
+
+
+        window.addEventListener('visibilitychange', listener, false);
+        window.addEventListener('focus', listener, false);
+        return () => {
+          // Be sure to unsubscribe if a new handler is set
+          window.removeEventListener('visibilitychange', listener);
+          window.removeEventListener('focus', listener);
+        };
+      }
+
+      return;
+    };
+  }
+
+  onSubscribe() {
+    if (!this.cleanup) {
+      this.setEventListener(this.setup);
+    }
+  }
+
+  onUnsubscribe() {
+    if (!this.hasListeners()) {
+      var _this$cleanup;
+
+      (_this$cleanup = this.cleanup) == null ? void 0 : _this$cleanup.call(this);
+      this.cleanup = undefined;
+    }
+  }
+
+  setEventListener(setup) {
+    var _this$cleanup2;
+
+    this.setup = setup;
+    (_this$cleanup2 = this.cleanup) == null ? void 0 : _this$cleanup2.call(this);
+    this.cleanup = setup(focused => {
+      if (typeof focused === 'boolean') {
+        this.setFocused(focused);
+      } else {
+        this.onFocus();
+      }
+    });
+  }
+
+  setFocused(focused) {
+    const changed = this.focused !== focused;
+
+    if (changed) {
+      this.focused = focused;
+      this.onFocus();
+    }
+  }
+
+  onFocus() {
+    this.listeners.forEach(({
+      listener
+    }) => {
+      listener();
+    });
+  }
+
+  isFocused() {
+    if (typeof this.focused === 'boolean') {
+      return this.focused;
+    } // document global can be unavailable in react native
+
+
+    if (typeof document === 'undefined') {
+      return true;
+    }
+
+    return [undefined, 'visible', 'prerender'].includes(document.visibilityState);
+  }
+
+}
+const focusManager = new FocusManager();
+
+const onlineEvents = ['online', 'offline'];
+class OnlineManager extends Subscribable {
+  constructor() {
+    super();
+
+    this.setup = onOnline => {
+      // addEventListener does not exist in React Native, but window does
+      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+      if (!isServer && window.addEventListener) {
+        const listener = () => onOnline(); // Listen to online
+
+
+        onlineEvents.forEach(event => {
+          window.addEventListener(event, listener, false);
+        });
+        return () => {
+          // Be sure to unsubscribe if a new handler is set
+          onlineEvents.forEach(event => {
+            window.removeEventListener(event, listener);
+          });
+        };
+      }
+
+      return;
+    };
+  }
+
+  onSubscribe() {
+    if (!this.cleanup) {
+      this.setEventListener(this.setup);
+    }
+  }
+
+  onUnsubscribe() {
+    if (!this.hasListeners()) {
+      var _this$cleanup;
+
+      (_this$cleanup = this.cleanup) == null ? void 0 : _this$cleanup.call(this);
+      this.cleanup = undefined;
+    }
+  }
+
+  setEventListener(setup) {
+    var _this$cleanup2;
+
+    this.setup = setup;
+    (_this$cleanup2 = this.cleanup) == null ? void 0 : _this$cleanup2.call(this);
+    this.cleanup = setup(online => {
+      if (typeof online === 'boolean') {
+        this.setOnline(online);
+      } else {
+        this.onOnline();
+      }
+    });
+  }
+
+  setOnline(online) {
+    const changed = this.online !== online;
+
+    if (changed) {
+      this.online = online;
+      this.onOnline();
+    }
+  }
+
+  onOnline() {
+    this.listeners.forEach(({
+      listener
+    }) => {
+      listener();
+    });
+  }
+
+  isOnline() {
+    if (typeof this.online === 'boolean') {
+      return this.online;
+    }
+
+    if (typeof navigator === 'undefined' || typeof navigator.onLine === 'undefined') {
+      return true;
+    }
+
+    return navigator.onLine;
+  }
+
+}
+const onlineManager = new OnlineManager();
+
+function defaultRetryDelay(failureCount) {
+  return Math.min(1000 * 2 ** failureCount, 30000);
+}
+
+function canFetch(networkMode) {
+  return (networkMode != null ? networkMode : 'online') === 'online' ? onlineManager.isOnline() : true;
+}
+class CancelledError {
+  constructor(options) {
+    this.revert = options == null ? void 0 : options.revert;
+    this.silent = options == null ? void 0 : options.silent;
+  }
+
+}
+function isCancelledError(value) {
+  return value instanceof CancelledError;
+}
+function createRetryer(config) {
+  let isRetryCancelled = false;
+  let failureCount = 0;
+  let isResolved = false;
+  let continueFn;
+  let promiseResolve;
+  let promiseReject;
+  const promise = new Promise((outerResolve, outerReject) => {
+    promiseResolve = outerResolve;
+    promiseReject = outerReject;
+  });
+
+  const cancel = cancelOptions => {
+    if (!isResolved) {
+      reject(new CancelledError(cancelOptions));
+      config.abort == null ? void 0 : config.abort();
+    }
+  };
+
+  const cancelRetry = () => {
+    isRetryCancelled = true;
+  };
+
+  const continueRetry = () => {
+    isRetryCancelled = false;
+  };
+
+  const shouldPause = () => !focusManager.isFocused() || config.networkMode !== 'always' && !onlineManager.isOnline();
+
+  const resolve = value => {
+    if (!isResolved) {
+      isResolved = true;
+      config.onSuccess == null ? void 0 : config.onSuccess(value);
+      continueFn == null ? void 0 : continueFn();
+      promiseResolve(value);
+    }
+  };
+
+  const reject = value => {
+    if (!isResolved) {
+      isResolved = true;
+      config.onError == null ? void 0 : config.onError(value);
+      continueFn == null ? void 0 : continueFn();
+      promiseReject(value);
+    }
+  };
+
+  const pause = () => {
+    return new Promise(continueResolve => {
+      continueFn = value => {
+        const canContinue = isResolved || !shouldPause();
+
+        if (canContinue) {
+          continueResolve(value);
+        }
+
+        return canContinue;
+      };
+
+      config.onPause == null ? void 0 : config.onPause();
+    }).then(() => {
+      continueFn = undefined;
+
+      if (!isResolved) {
+        config.onContinue == null ? void 0 : config.onContinue();
+      }
+    });
+  }; // Create loop function
+
+
+  const run = () => {
+    // Do nothing if already resolved
+    if (isResolved) {
+      return;
+    }
+
+    let promiseOrValue; // Execute query
+
+    try {
+      promiseOrValue = config.fn();
+    } catch (error) {
+      promiseOrValue = Promise.reject(error);
+    }
+
+    Promise.resolve(promiseOrValue).then(resolve).catch(error => {
+      var _config$retry, _config$retryDelay;
+
+      // Stop if the fetch is already resolved
+      if (isResolved) {
+        return;
+      } // Do we need to retry the request?
+
+
+      const retry = (_config$retry = config.retry) != null ? _config$retry : 3;
+      const retryDelay = (_config$retryDelay = config.retryDelay) != null ? _config$retryDelay : defaultRetryDelay;
+      const delay = typeof retryDelay === 'function' ? retryDelay(failureCount, error) : retryDelay;
+      const shouldRetry = retry === true || typeof retry === 'number' && failureCount < retry || typeof retry === 'function' && retry(failureCount, error);
+
+      if (isRetryCancelled || !shouldRetry) {
+        // We are done if the query does not need to be retried
+        reject(error);
+        return;
+      }
+
+      failureCount++; // Notify on fail
+
+      config.onFail == null ? void 0 : config.onFail(failureCount, error); // Delay
+
+      sleep$1(delay) // Pause if the document is not visible or when the device is offline
+      .then(() => {
+        if (shouldPause()) {
+          return pause();
+        }
+
+        return;
+      }).then(() => {
+        if (isRetryCancelled) {
+          reject(error);
+        } else {
+          run();
+        }
+      });
+    });
+  }; // Start loop
+
+
+  if (canFetch(config.networkMode)) {
+    run();
+  } else {
+    pause().then(run);
+  }
+
+  return {
+    promise,
+    cancel,
+    continue: () => {
+      const didContinue = continueFn == null ? void 0 : continueFn();
+      return didContinue ? promise : Promise.resolve();
+    },
+    cancelRetry,
+    continueRetry
+  };
+}
+
+const defaultLogger = console;
+
+function createNotifyManager() {
+  let queue = [];
+  let transactions = 0;
+
+  let notifyFn = callback => {
+    callback();
+  };
+
+  let batchNotifyFn = callback => {
+    callback();
+  };
+
+  const batch = callback => {
+    let result;
+    transactions++;
+
+    try {
+      result = callback();
+    } finally {
+      transactions--;
+
+      if (!transactions) {
+        flush();
+      }
+    }
+
+    return result;
+  };
+
+  const schedule = callback => {
+    if (transactions) {
+      queue.push(callback);
+    } else {
+      scheduleMicrotask(() => {
+        notifyFn(callback);
+      });
+    }
+  };
+  /**
+   * All calls to the wrapped function will be batched.
+   */
+
+
+  const batchCalls = callback => {
+    return (...args) => {
+      schedule(() => {
+        callback(...args);
+      });
+    };
+  };
+
+  const flush = () => {
+    const originalQueue = queue;
+    queue = [];
+
+    if (originalQueue.length) {
+      scheduleMicrotask(() => {
+        batchNotifyFn(() => {
+          originalQueue.forEach(callback => {
+            notifyFn(callback);
+          });
+        });
+      });
+    }
+  };
+  /**
+   * Use this method to set a custom notify function.
+   * This can be used to for example wrap notifications with `React.act` while running tests.
+   */
+
+
+  const setNotifyFunction = fn => {
+    notifyFn = fn;
+  };
+  /**
+   * Use this method to set a custom function to batch notifications together into a single tick.
+   * By default React Query will use the batch function provided by ReactDOM or React Native.
+   */
+
+
+  const setBatchNotifyFunction = fn => {
+    batchNotifyFn = fn;
+  };
+
+  return {
+    batch,
+    batchCalls,
+    schedule,
+    setNotifyFunction,
+    setBatchNotifyFunction
+  };
+} // SINGLETON
+
+const notifyManager = createNotifyManager();
+
+class Removable {
+  destroy() {
+    this.clearGcTimeout();
+  }
+
+  scheduleGc() {
+    this.clearGcTimeout();
+
+    if (isValidTimeout(this.cacheTime)) {
+      this.gcTimeout = setTimeout(() => {
+        this.optionalRemove();
+      }, this.cacheTime);
+    }
+  }
+
+  updateCacheTime(newCacheTime) {
+    // Default to 5 minutes (Infinity for server-side) if no cache time is set
+    this.cacheTime = Math.max(this.cacheTime || 0, newCacheTime != null ? newCacheTime : isServer ? Infinity : 5 * 60 * 1000);
+  }
+
+  clearGcTimeout() {
+    if (this.gcTimeout) {
+      clearTimeout(this.gcTimeout);
+      this.gcTimeout = undefined;
+    }
+  }
+
+}
+
+// CLASS
+class Query extends Removable {
+  constructor(config) {
+    super();
+    this.abortSignalConsumed = false;
+    this.defaultOptions = config.defaultOptions;
+    this.setOptions(config.options);
+    this.observers = [];
+    this.cache = config.cache;
+    this.logger = config.logger || defaultLogger;
+    this.queryKey = config.queryKey;
+    this.queryHash = config.queryHash;
+    this.initialState = config.state || getDefaultState$1(this.options);
+    this.state = this.initialState;
+    this.scheduleGc();
+  }
+
+  get meta() {
+    return this.options.meta;
+  }
+
+  setOptions(options) {
+    this.options = { ...this.defaultOptions,
+      ...options
+    };
+    this.updateCacheTime(this.options.cacheTime);
+  }
+
+  optionalRemove() {
+    if (!this.observers.length && this.state.fetchStatus === 'idle') {
+      this.cache.remove(this);
+    }
+  }
+
+  setData(newData, options) {
+    const data = replaceData(this.state.data, newData, this.options); // Set data and mark it as cached
+
+    this.dispatch({
+      data,
+      type: 'success',
+      dataUpdatedAt: options == null ? void 0 : options.updatedAt,
+      manual: options == null ? void 0 : options.manual
+    });
+    return data;
+  }
+
+  setState(state, setStateOptions) {
+    this.dispatch({
+      type: 'setState',
+      state,
+      setStateOptions
+    });
+  }
+
+  cancel(options) {
+    var _this$retryer;
+
+    const promise = this.promise;
+    (_this$retryer = this.retryer) == null ? void 0 : _this$retryer.cancel(options);
+    return promise ? promise.then(noop$1).catch(noop$1) : Promise.resolve();
+  }
+
+  destroy() {
+    super.destroy();
+    this.cancel({
+      silent: true
+    });
+  }
+
+  reset() {
+    this.destroy();
+    this.setState(this.initialState);
+  }
+
+  isActive() {
+    return this.observers.some(observer => observer.options.enabled !== false);
+  }
+
+  isDisabled() {
+    return this.getObserversCount() > 0 && !this.isActive();
+  }
+
+  isStale() {
+    return this.state.isInvalidated || !this.state.dataUpdatedAt || this.observers.some(observer => observer.getCurrentResult().isStale);
+  }
+
+  isStaleByTime(staleTime = 0) {
+    return this.state.isInvalidated || !this.state.dataUpdatedAt || !timeUntilStale(this.state.dataUpdatedAt, staleTime);
+  }
+
+  onFocus() {
+    var _this$retryer2;
+
+    const observer = this.observers.find(x => x.shouldFetchOnWindowFocus());
+
+    if (observer) {
+      observer.refetch({
+        cancelRefetch: false
+      });
+    } // Continue fetch if currently paused
+
+
+    (_this$retryer2 = this.retryer) == null ? void 0 : _this$retryer2.continue();
+  }
+
+  onOnline() {
+    var _this$retryer3;
+
+    const observer = this.observers.find(x => x.shouldFetchOnReconnect());
+
+    if (observer) {
+      observer.refetch({
+        cancelRefetch: false
+      });
+    } // Continue fetch if currently paused
+
+
+    (_this$retryer3 = this.retryer) == null ? void 0 : _this$retryer3.continue();
+  }
+
+  addObserver(observer) {
+    if (!this.observers.includes(observer)) {
+      this.observers.push(observer); // Stop the query from being garbage collected
+
+      this.clearGcTimeout();
+      this.cache.notify({
+        type: 'observerAdded',
+        query: this,
+        observer
+      });
+    }
+  }
+
+  removeObserver(observer) {
+    if (this.observers.includes(observer)) {
+      this.observers = this.observers.filter(x => x !== observer);
+
+      if (!this.observers.length) {
+        // If the transport layer does not support cancellation
+        // we'll let the query continue so the result can be cached
+        if (this.retryer) {
+          if (this.abortSignalConsumed) {
+            this.retryer.cancel({
+              revert: true
+            });
+          } else {
+            this.retryer.cancelRetry();
+          }
+        }
+
+        this.scheduleGc();
+      }
+
+      this.cache.notify({
+        type: 'observerRemoved',
+        query: this,
+        observer
+      });
+    }
+  }
+
+  getObserversCount() {
+    return this.observers.length;
+  }
+
+  invalidate() {
+    if (!this.state.isInvalidated) {
+      this.dispatch({
+        type: 'invalidate'
+      });
+    }
+  }
+
+  fetch(options, fetchOptions) {
+    var _this$options$behavio, _context$fetchOptions;
+
+    if (this.state.fetchStatus !== 'idle') {
+      if (this.state.dataUpdatedAt && fetchOptions != null && fetchOptions.cancelRefetch) {
+        // Silently cancel current fetch if the user wants to cancel refetches
+        this.cancel({
+          silent: true
+        });
+      } else if (this.promise) {
+        var _this$retryer4;
+
+        // make sure that retries that were potentially cancelled due to unmounts can continue
+        (_this$retryer4 = this.retryer) == null ? void 0 : _this$retryer4.continueRetry(); // Return current promise if we are already fetching
+
+        return this.promise;
+      }
+    } // Update config if passed, otherwise the config from the last execution is used
+
+
+    if (options) {
+      this.setOptions(options);
+    } // Use the options from the first observer with a query function if no function is found.
+    // This can happen when the query is hydrated or created with setQueryData.
+
+
+    if (!this.options.queryFn) {
+      const observer = this.observers.find(x => x.options.queryFn);
+
+      if (observer) {
+        this.setOptions(observer.options);
+      }
+    }
+
+    if (process.env.NODE_ENV !== 'production') {
+      if (!Array.isArray(this.options.queryKey)) {
+        this.logger.error("As of v4, queryKey needs to be an Array. If you are using a string like 'repoData', please change it to an Array, e.g. ['repoData']");
+      }
+    }
+
+    const abortController = getAbortController(); // Create query function context
+
+    const queryFnContext = {
+      queryKey: this.queryKey,
+      pageParam: undefined,
+      meta: this.meta
+    }; // Adds an enumerable signal property to the object that
+    // which sets abortSignalConsumed to true when the signal
+    // is read.
+
+    const addSignalProperty = object => {
+      Object.defineProperty(object, 'signal', {
+        enumerable: true,
+        get: () => {
+          if (abortController) {
+            this.abortSignalConsumed = true;
+            return abortController.signal;
+          }
+
+          return undefined;
+        }
+      });
+    };
+
+    addSignalProperty(queryFnContext); // Create fetch function
+
+    const fetchFn = () => {
+      if (!this.options.queryFn) {
+        return Promise.reject("Missing queryFn for queryKey '" + this.options.queryHash + "'");
+      }
+
+      this.abortSignalConsumed = false;
+      return this.options.queryFn(queryFnContext);
+    }; // Trigger behavior hook
+
+
+    const context = {
+      fetchOptions,
+      options: this.options,
+      queryKey: this.queryKey,
+      state: this.state,
+      fetchFn
+    };
+    addSignalProperty(context);
+    (_this$options$behavio = this.options.behavior) == null ? void 0 : _this$options$behavio.onFetch(context); // Store state in case the current fetch needs to be reverted
+
+    this.revertState = this.state; // Set to fetching state if not already in it
+
+    if (this.state.fetchStatus === 'idle' || this.state.fetchMeta !== ((_context$fetchOptions = context.fetchOptions) == null ? void 0 : _context$fetchOptions.meta)) {
+      var _context$fetchOptions2;
+
+      this.dispatch({
+        type: 'fetch',
+        meta: (_context$fetchOptions2 = context.fetchOptions) == null ? void 0 : _context$fetchOptions2.meta
+      });
+    }
+
+    const onError = error => {
+      // Optimistically update state if needed
+      if (!(isCancelledError(error) && error.silent)) {
+        this.dispatch({
+          type: 'error',
+          error: error
+        });
+      }
+
+      if (!isCancelledError(error)) {
+        var _this$cache$config$on, _this$cache$config, _this$cache$config$on2, _this$cache$config2;
+
+        // Notify cache callback
+        (_this$cache$config$on = (_this$cache$config = this.cache.config).onError) == null ? void 0 : _this$cache$config$on.call(_this$cache$config, error, this);
+        (_this$cache$config$on2 = (_this$cache$config2 = this.cache.config).onSettled) == null ? void 0 : _this$cache$config$on2.call(_this$cache$config2, this.state.data, error, this);
+
+        if (process.env.NODE_ENV !== 'production') {
+          this.logger.error(error);
+        }
+      }
+
+      if (!this.isFetchingOptimistic) {
+        // Schedule query gc after fetching
+        this.scheduleGc();
+      }
+
+      this.isFetchingOptimistic = false;
+    }; // Try to fetch the data
+
+
+    this.retryer = createRetryer({
+      fn: context.fetchFn,
+      abort: abortController == null ? void 0 : abortController.abort.bind(abortController),
+      onSuccess: data => {
+        var _this$cache$config$on3, _this$cache$config3, _this$cache$config$on4, _this$cache$config4;
+
+        if (typeof data === 'undefined') {
+          if (process.env.NODE_ENV !== 'production') {
+            this.logger.error("Query data cannot be undefined. Please make sure to return a value other than undefined from your query function. Affected query key: " + this.queryHash);
+          }
+
+          onError(new Error(this.queryHash + " data is undefined"));
+          return;
+        }
+
+        this.setData(data); // Notify cache callback
+
+        (_this$cache$config$on3 = (_this$cache$config3 = this.cache.config).onSuccess) == null ? void 0 : _this$cache$config$on3.call(_this$cache$config3, data, this);
+        (_this$cache$config$on4 = (_this$cache$config4 = this.cache.config).onSettled) == null ? void 0 : _this$cache$config$on4.call(_this$cache$config4, data, this.state.error, this);
+
+        if (!this.isFetchingOptimistic) {
+          // Schedule query gc after fetching
+          this.scheduleGc();
+        }
+
+        this.isFetchingOptimistic = false;
+      },
+      onError,
+      onFail: (failureCount, error) => {
+        this.dispatch({
+          type: 'failed',
+          failureCount,
+          error
+        });
+      },
+      onPause: () => {
+        this.dispatch({
+          type: 'pause'
+        });
+      },
+      onContinue: () => {
+        this.dispatch({
+          type: 'continue'
+        });
+      },
+      retry: context.options.retry,
+      retryDelay: context.options.retryDelay,
+      networkMode: context.options.networkMode
+    });
+    this.promise = this.retryer.promise;
+    return this.promise;
+  }
+
+  dispatch(action) {
+    const reducer = state => {
+      var _action$meta, _action$dataUpdatedAt;
+
+      switch (action.type) {
+        case 'failed':
+          return { ...state,
+            fetchFailureCount: action.failureCount,
+            fetchFailureReason: action.error
+          };
+
+        case 'pause':
+          return { ...state,
+            fetchStatus: 'paused'
+          };
+
+        case 'continue':
+          return { ...state,
+            fetchStatus: 'fetching'
+          };
+
+        case 'fetch':
+          return { ...state,
+            fetchFailureCount: 0,
+            fetchFailureReason: null,
+            fetchMeta: (_action$meta = action.meta) != null ? _action$meta : null,
+            fetchStatus: canFetch(this.options.networkMode) ? 'fetching' : 'paused',
+            ...(!state.dataUpdatedAt && {
+              error: null,
+              status: 'loading'
+            })
+          };
+
+        case 'success':
+          return { ...state,
+            data: action.data,
+            dataUpdateCount: state.dataUpdateCount + 1,
+            dataUpdatedAt: (_action$dataUpdatedAt = action.dataUpdatedAt) != null ? _action$dataUpdatedAt : Date.now(),
+            error: null,
+            isInvalidated: false,
+            status: 'success',
+            ...(!action.manual && {
+              fetchStatus: 'idle',
+              fetchFailureCount: 0,
+              fetchFailureReason: null
+            })
+          };
+
+        case 'error':
+          const error = action.error;
+
+          if (isCancelledError(error) && error.revert && this.revertState) {
+            return { ...this.revertState,
+              fetchStatus: 'idle'
+            };
+          }
+
+          return { ...state,
+            error: error,
+            errorUpdateCount: state.errorUpdateCount + 1,
+            errorUpdatedAt: Date.now(),
+            fetchFailureCount: state.fetchFailureCount + 1,
+            fetchFailureReason: error,
+            fetchStatus: 'idle',
+            status: 'error'
+          };
+
+        case 'invalidate':
+          return { ...state,
+            isInvalidated: true
+          };
+
+        case 'setState':
+          return { ...state,
+            ...action.state
+          };
+      }
+    };
+
+    this.state = reducer(this.state);
+    notifyManager.batch(() => {
+      this.observers.forEach(observer => {
+        observer.onQueryUpdate(action);
+      });
+      this.cache.notify({
+        query: this,
+        type: 'updated',
+        action
+      });
+    });
+  }
+
+}
+
+function getDefaultState$1(options) {
+  const data = typeof options.initialData === 'function' ? options.initialData() : options.initialData;
+  const hasData = typeof data !== 'undefined';
+  const initialDataUpdatedAt = hasData ? typeof options.initialDataUpdatedAt === 'function' ? options.initialDataUpdatedAt() : options.initialDataUpdatedAt : 0;
+  return {
+    data,
+    dataUpdateCount: 0,
+    dataUpdatedAt: hasData ? initialDataUpdatedAt != null ? initialDataUpdatedAt : Date.now() : 0,
+    error: null,
+    errorUpdateCount: 0,
+    errorUpdatedAt: 0,
+    fetchFailureCount: 0,
+    fetchFailureReason: null,
+    fetchMeta: null,
+    isInvalidated: false,
+    status: hasData ? 'success' : 'loading',
+    fetchStatus: 'idle'
+  };
+}
+
+// CLASS
+class QueryCache extends Subscribable {
+  constructor(config) {
+    super();
+    this.config = config || {};
+    this.queries = [];
+    this.queriesMap = {};
+  }
+
+  build(client, options, state) {
+    var _options$queryHash;
+
+    const queryKey = options.queryKey;
+    const queryHash = (_options$queryHash = options.queryHash) != null ? _options$queryHash : hashQueryKeyByOptions(queryKey, options);
+    let query = this.get(queryHash);
+
+    if (!query) {
+      query = new Query({
+        cache: this,
+        logger: client.getLogger(),
+        queryKey,
+        queryHash,
+        options: client.defaultQueryOptions(options),
+        state,
+        defaultOptions: client.getQueryDefaults(queryKey)
+      });
+      this.add(query);
+    }
+
+    return query;
+  }
+
+  add(query) {
+    if (!this.queriesMap[query.queryHash]) {
+      this.queriesMap[query.queryHash] = query;
+      this.queries.push(query);
+      this.notify({
+        type: 'added',
+        query
+      });
+    }
+  }
+
+  remove(query) {
+    const queryInMap = this.queriesMap[query.queryHash];
+
+    if (queryInMap) {
+      query.destroy();
+      this.queries = this.queries.filter(x => x !== query);
+
+      if (queryInMap === query) {
+        delete this.queriesMap[query.queryHash];
+      }
+
+      this.notify({
+        type: 'removed',
+        query
+      });
+    }
+  }
+
+  clear() {
+    notifyManager.batch(() => {
+      this.queries.forEach(query => {
+        this.remove(query);
+      });
+    });
+  }
+
+  get(queryHash) {
+    return this.queriesMap[queryHash];
+  }
+
+  getAll() {
+    return this.queries;
+  }
+
+  find(arg1, arg2) {
+    const [filters] = parseFilterArgs(arg1, arg2);
+
+    if (typeof filters.exact === 'undefined') {
+      filters.exact = true;
+    }
+
+    return this.queries.find(query => matchQuery(filters, query));
+  }
+
+  findAll(arg1, arg2) {
+    const [filters] = parseFilterArgs(arg1, arg2);
+    return Object.keys(filters).length > 0 ? this.queries.filter(query => matchQuery(filters, query)) : this.queries;
+  }
+
+  notify(event) {
+    notifyManager.batch(() => {
+      this.listeners.forEach(({
+        listener
+      }) => {
+        listener(event);
+      });
+    });
+  }
+
+  onFocus() {
+    notifyManager.batch(() => {
+      this.queries.forEach(query => {
+        query.onFocus();
+      });
+    });
+  }
+
+  onOnline() {
+    notifyManager.batch(() => {
+      this.queries.forEach(query => {
+        query.onOnline();
+      });
+    });
+  }
+
+}
+
+// CLASS
+class Mutation extends Removable {
+  constructor(config) {
+    super();
+    this.defaultOptions = config.defaultOptions;
+    this.mutationId = config.mutationId;
+    this.mutationCache = config.mutationCache;
+    this.logger = config.logger || defaultLogger;
+    this.observers = [];
+    this.state = config.state || getDefaultState();
+    this.setOptions(config.options);
+    this.scheduleGc();
+  }
+
+  setOptions(options) {
+    this.options = { ...this.defaultOptions,
+      ...options
+    };
+    this.updateCacheTime(this.options.cacheTime);
+  }
+
+  get meta() {
+    return this.options.meta;
+  }
+
+  setState(state) {
+    this.dispatch({
+      type: 'setState',
+      state
+    });
+  }
+
+  addObserver(observer) {
+    if (!this.observers.includes(observer)) {
+      this.observers.push(observer); // Stop the mutation from being garbage collected
+
+      this.clearGcTimeout();
+      this.mutationCache.notify({
+        type: 'observerAdded',
+        mutation: this,
+        observer
+      });
+    }
+  }
+
+  removeObserver(observer) {
+    this.observers = this.observers.filter(x => x !== observer);
+    this.scheduleGc();
+    this.mutationCache.notify({
+      type: 'observerRemoved',
+      mutation: this,
+      observer
+    });
+  }
+
+  optionalRemove() {
+    if (!this.observers.length) {
+      if (this.state.status === 'loading') {
+        this.scheduleGc();
+      } else {
+        this.mutationCache.remove(this);
+      }
+    }
+  }
+
+  continue() {
+    var _this$retryer$continu, _this$retryer;
+
+    return (_this$retryer$continu = (_this$retryer = this.retryer) == null ? void 0 : _this$retryer.continue()) != null ? _this$retryer$continu : this.execute();
+  }
+
+  async execute() {
+    const executeMutation = () => {
+      var _this$options$retry;
+
+      this.retryer = createRetryer({
+        fn: () => {
+          if (!this.options.mutationFn) {
+            return Promise.reject('No mutationFn found');
+          }
+
+          return this.options.mutationFn(this.state.variables);
+        },
+        onFail: (failureCount, error) => {
+          this.dispatch({
+            type: 'failed',
+            failureCount,
+            error
+          });
+        },
+        onPause: () => {
+          this.dispatch({
+            type: 'pause'
+          });
+        },
+        onContinue: () => {
+          this.dispatch({
+            type: 'continue'
+          });
+        },
+        retry: (_this$options$retry = this.options.retry) != null ? _this$options$retry : 0,
+        retryDelay: this.options.retryDelay,
+        networkMode: this.options.networkMode
+      });
+      return this.retryer.promise;
+    };
+
+    const restored = this.state.status === 'loading';
+
+    try {
+      var _this$mutationCache$c3, _this$mutationCache$c4, _this$options$onSucce, _this$options2, _this$mutationCache$c5, _this$mutationCache$c6, _this$options$onSettl, _this$options3;
+
+      if (!restored) {
+        var _this$mutationCache$c, _this$mutationCache$c2, _this$options$onMutat, _this$options;
+
+        this.dispatch({
+          type: 'loading',
+          variables: this.options.variables
+        }); // Notify cache callback
+
+        await ((_this$mutationCache$c = (_this$mutationCache$c2 = this.mutationCache.config).onMutate) == null ? void 0 : _this$mutationCache$c.call(_this$mutationCache$c2, this.state.variables, this));
+        const context = await ((_this$options$onMutat = (_this$options = this.options).onMutate) == null ? void 0 : _this$options$onMutat.call(_this$options, this.state.variables));
+
+        if (context !== this.state.context) {
+          this.dispatch({
+            type: 'loading',
+            context,
+            variables: this.state.variables
+          });
+        }
+      }
+
+      const data = await executeMutation(); // Notify cache callback
+
+      await ((_this$mutationCache$c3 = (_this$mutationCache$c4 = this.mutationCache.config).onSuccess) == null ? void 0 : _this$mutationCache$c3.call(_this$mutationCache$c4, data, this.state.variables, this.state.context, this));
+      await ((_this$options$onSucce = (_this$options2 = this.options).onSuccess) == null ? void 0 : _this$options$onSucce.call(_this$options2, data, this.state.variables, this.state.context)); // Notify cache callback
+
+      await ((_this$mutationCache$c5 = (_this$mutationCache$c6 = this.mutationCache.config).onSettled) == null ? void 0 : _this$mutationCache$c5.call(_this$mutationCache$c6, data, null, this.state.variables, this.state.context, this));
+      await ((_this$options$onSettl = (_this$options3 = this.options).onSettled) == null ? void 0 : _this$options$onSettl.call(_this$options3, data, null, this.state.variables, this.state.context));
+      this.dispatch({
+        type: 'success',
+        data
+      });
+      return data;
+    } catch (error) {
+      try {
+        var _this$mutationCache$c7, _this$mutationCache$c8, _this$options$onError, _this$options4, _this$mutationCache$c9, _this$mutationCache$c10, _this$options$onSettl2, _this$options5;
+
+        // Notify cache callback
+        await ((_this$mutationCache$c7 = (_this$mutationCache$c8 = this.mutationCache.config).onError) == null ? void 0 : _this$mutationCache$c7.call(_this$mutationCache$c8, error, this.state.variables, this.state.context, this));
+
+        if (process.env.NODE_ENV !== 'production') {
+          this.logger.error(error);
+        }
+
+        await ((_this$options$onError = (_this$options4 = this.options).onError) == null ? void 0 : _this$options$onError.call(_this$options4, error, this.state.variables, this.state.context)); // Notify cache callback
+
+        await ((_this$mutationCache$c9 = (_this$mutationCache$c10 = this.mutationCache.config).onSettled) == null ? void 0 : _this$mutationCache$c9.call(_this$mutationCache$c10, undefined, error, this.state.variables, this.state.context, this));
+        await ((_this$options$onSettl2 = (_this$options5 = this.options).onSettled) == null ? void 0 : _this$options$onSettl2.call(_this$options5, undefined, error, this.state.variables, this.state.context));
+        throw error;
+      } finally {
+        this.dispatch({
+          type: 'error',
+          error: error
+        });
+      }
+    }
+  }
+
+  dispatch(action) {
+    const reducer = state => {
+      switch (action.type) {
+        case 'failed':
+          return { ...state,
+            failureCount: action.failureCount,
+            failureReason: action.error
+          };
+
+        case 'pause':
+          return { ...state,
+            isPaused: true
+          };
+
+        case 'continue':
+          return { ...state,
+            isPaused: false
+          };
+
+        case 'loading':
+          return { ...state,
+            context: action.context,
+            data: undefined,
+            failureCount: 0,
+            failureReason: null,
+            error: null,
+            isPaused: !canFetch(this.options.networkMode),
+            status: 'loading',
+            variables: action.variables
+          };
+
+        case 'success':
+          return { ...state,
+            data: action.data,
+            failureCount: 0,
+            failureReason: null,
+            error: null,
+            status: 'success',
+            isPaused: false
+          };
+
+        case 'error':
+          return { ...state,
+            data: undefined,
+            error: action.error,
+            failureCount: state.failureCount + 1,
+            failureReason: action.error,
+            isPaused: false,
+            status: 'error'
+          };
+
+        case 'setState':
+          return { ...state,
+            ...action.state
+          };
+      }
+    };
+
+    this.state = reducer(this.state);
+    notifyManager.batch(() => {
+      this.observers.forEach(observer => {
+        observer.onMutationUpdate(action);
+      });
+      this.mutationCache.notify({
+        mutation: this,
+        type: 'updated',
+        action
+      });
+    });
+  }
+
+}
+function getDefaultState() {
+  return {
+    context: undefined,
+    data: undefined,
+    error: null,
+    failureCount: 0,
+    failureReason: null,
+    isPaused: false,
+    status: 'idle',
+    variables: undefined
+  };
+}
+
+// CLASS
+class MutationCache extends Subscribable {
+  constructor(config) {
+    super();
+    this.config = config || {};
+    this.mutations = [];
+    this.mutationId = 0;
+  }
+
+  build(client, options, state) {
+    const mutation = new Mutation({
+      mutationCache: this,
+      logger: client.getLogger(),
+      mutationId: ++this.mutationId,
+      options: client.defaultMutationOptions(options),
+      state,
+      defaultOptions: options.mutationKey ? client.getMutationDefaults(options.mutationKey) : undefined
+    });
+    this.add(mutation);
+    return mutation;
+  }
+
+  add(mutation) {
+    this.mutations.push(mutation);
+    this.notify({
+      type: 'added',
+      mutation
+    });
+  }
+
+  remove(mutation) {
+    this.mutations = this.mutations.filter(x => x !== mutation);
+    this.notify({
+      type: 'removed',
+      mutation
+    });
+  }
+
+  clear() {
+    notifyManager.batch(() => {
+      this.mutations.forEach(mutation => {
+        this.remove(mutation);
+      });
+    });
+  }
+
+  getAll() {
+    return this.mutations;
+  }
+
+  find(filters) {
+    if (typeof filters.exact === 'undefined') {
+      filters.exact = true;
+    }
+
+    return this.mutations.find(mutation => matchMutation(filters, mutation));
+  }
+
+  findAll(filters) {
+    return this.mutations.filter(mutation => matchMutation(filters, mutation));
+  }
+
+  notify(event) {
+    notifyManager.batch(() => {
+      this.listeners.forEach(({
+        listener
+      }) => {
+        listener(event);
+      });
+    });
+  }
+
+  resumePausedMutations() {
+    var _this$resuming;
+
+    this.resuming = ((_this$resuming = this.resuming) != null ? _this$resuming : Promise.resolve()).then(() => {
+      const pausedMutations = this.mutations.filter(x => x.state.isPaused);
+      return notifyManager.batch(() => pausedMutations.reduce((promise, mutation) => promise.then(() => mutation.continue().catch(noop$1)), Promise.resolve()));
+    }).then(() => {
+      this.resuming = undefined;
+    });
+    return this.resuming;
+  }
+
+}
+
+function infiniteQueryBehavior() {
+  return {
+    onFetch: context => {
+      context.fetchFn = () => {
+        var _context$fetchOptions, _context$fetchOptions2, _context$fetchOptions3, _context$fetchOptions4, _context$state$data, _context$state$data2;
+
+        const refetchPage = (_context$fetchOptions = context.fetchOptions) == null ? void 0 : (_context$fetchOptions2 = _context$fetchOptions.meta) == null ? void 0 : _context$fetchOptions2.refetchPage;
+        const fetchMore = (_context$fetchOptions3 = context.fetchOptions) == null ? void 0 : (_context$fetchOptions4 = _context$fetchOptions3.meta) == null ? void 0 : _context$fetchOptions4.fetchMore;
+        const pageParam = fetchMore == null ? void 0 : fetchMore.pageParam;
+        const isFetchingNextPage = (fetchMore == null ? void 0 : fetchMore.direction) === 'forward';
+        const isFetchingPreviousPage = (fetchMore == null ? void 0 : fetchMore.direction) === 'backward';
+        const oldPages = ((_context$state$data = context.state.data) == null ? void 0 : _context$state$data.pages) || [];
+        const oldPageParams = ((_context$state$data2 = context.state.data) == null ? void 0 : _context$state$data2.pageParams) || [];
+        let newPageParams = oldPageParams;
+        let cancelled = false;
+
+        const addSignalProperty = object => {
+          Object.defineProperty(object, 'signal', {
+            enumerable: true,
+            get: () => {
+              var _context$signal;
+
+              if ((_context$signal = context.signal) != null && _context$signal.aborted) {
+                cancelled = true;
+              } else {
+                var _context$signal2;
+
+                (_context$signal2 = context.signal) == null ? void 0 : _context$signal2.addEventListener('abort', () => {
+                  cancelled = true;
+                });
+              }
+
+              return context.signal;
+            }
+          });
+        }; // Get query function
+
+
+        const queryFn = context.options.queryFn || (() => Promise.reject("Missing queryFn for queryKey '" + context.options.queryHash + "'"));
+
+        const buildNewPages = (pages, param, page, previous) => {
+          newPageParams = previous ? [param, ...newPageParams] : [...newPageParams, param];
+          return previous ? [page, ...pages] : [...pages, page];
+        }; // Create function to fetch a page
+
+
+        const fetchPage = (pages, manual, param, previous) => {
+          if (cancelled) {
+            return Promise.reject('Cancelled');
+          }
+
+          if (typeof param === 'undefined' && !manual && pages.length) {
+            return Promise.resolve(pages);
+          }
+
+          const queryFnContext = {
+            queryKey: context.queryKey,
+            pageParam: param,
+            meta: context.options.meta
+          };
+          addSignalProperty(queryFnContext);
+          const queryFnResult = queryFn(queryFnContext);
+          const promise = Promise.resolve(queryFnResult).then(page => buildNewPages(pages, param, page, previous));
+          return promise;
+        };
+
+        let promise; // Fetch first page?
+
+        if (!oldPages.length) {
+          promise = fetchPage([]);
+        } // Fetch next page?
+        else if (isFetchingNextPage) {
+          const manual = typeof pageParam !== 'undefined';
+          const param = manual ? pageParam : getNextPageParam(context.options, oldPages);
+          promise = fetchPage(oldPages, manual, param);
+        } // Fetch previous page?
+        else if (isFetchingPreviousPage) {
+          const manual = typeof pageParam !== 'undefined';
+          const param = manual ? pageParam : getPreviousPageParam(context.options, oldPages);
+          promise = fetchPage(oldPages, manual, param, true);
+        } // Refetch pages
+        else {
+          newPageParams = [];
+          const manual = typeof context.options.getNextPageParam === 'undefined';
+          const shouldFetchFirstPage = refetchPage && oldPages[0] ? refetchPage(oldPages[0], 0, oldPages) : true; // Fetch first page
+
+          promise = shouldFetchFirstPage ? fetchPage([], manual, oldPageParams[0]) : Promise.resolve(buildNewPages([], oldPageParams[0], oldPages[0])); // Fetch remaining pages
+
+          for (let i = 1; i < oldPages.length; i++) {
+            promise = promise.then(pages => {
+              const shouldFetchNextPage = refetchPage && oldPages[i] ? refetchPage(oldPages[i], i, oldPages) : true;
+
+              if (shouldFetchNextPage) {
+                const param = manual ? oldPageParams[i] : getNextPageParam(context.options, pages);
+                return fetchPage(pages, manual, param);
+              }
+
+              return Promise.resolve(buildNewPages(pages, oldPageParams[i], oldPages[i]));
+            });
+          }
+        }
+
+        const finalPromise = promise.then(pages => ({
+          pages,
+          pageParams: newPageParams
+        }));
+        return finalPromise;
+      };
+    }
+  };
+}
+function getNextPageParam(options, pages) {
+  return options.getNextPageParam == null ? void 0 : options.getNextPageParam(pages[pages.length - 1], pages);
+}
+function getPreviousPageParam(options, pages) {
+  return options.getPreviousPageParam == null ? void 0 : options.getPreviousPageParam(pages[0], pages);
+}
+
+// CLASS
+class QueryClient {
+  constructor(config = {}) {
+    this.queryCache = config.queryCache || new QueryCache();
+    this.mutationCache = config.mutationCache || new MutationCache();
+    this.logger = config.logger || defaultLogger;
+    this.defaultOptions = config.defaultOptions || {};
+    this.queryDefaults = [];
+    this.mutationDefaults = [];
+    this.mountCount = 0;
+
+    if (process.env.NODE_ENV !== 'production' && config.logger) {
+      this.logger.error("Passing a custom logger has been deprecated and will be removed in the next major version.");
+    }
+  }
+
+  mount() {
+    this.mountCount++;
+    if (this.mountCount !== 1) return;
+    this.unsubscribeFocus = focusManager.subscribe(() => {
+      if (focusManager.isFocused()) {
+        this.resumePausedMutations();
+        this.queryCache.onFocus();
+      }
+    });
+    this.unsubscribeOnline = onlineManager.subscribe(() => {
+      if (onlineManager.isOnline()) {
+        this.resumePausedMutations();
+        this.queryCache.onOnline();
+      }
+    });
+  }
+
+  unmount() {
+    var _this$unsubscribeFocu, _this$unsubscribeOnli;
+
+    this.mountCount--;
+    if (this.mountCount !== 0) return;
+    (_this$unsubscribeFocu = this.unsubscribeFocus) == null ? void 0 : _this$unsubscribeFocu.call(this);
+    this.unsubscribeFocus = undefined;
+    (_this$unsubscribeOnli = this.unsubscribeOnline) == null ? void 0 : _this$unsubscribeOnli.call(this);
+    this.unsubscribeOnline = undefined;
+  }
+
+  isFetching(arg1, arg2) {
+    const [filters] = parseFilterArgs(arg1, arg2);
+    filters.fetchStatus = 'fetching';
+    return this.queryCache.findAll(filters).length;
+  }
+
+  isMutating(filters) {
+    return this.mutationCache.findAll({ ...filters,
+      fetching: true
+    }).length;
+  }
+
+  getQueryData(queryKey, filters) {
+    var _this$queryCache$find;
+
+    return (_this$queryCache$find = this.queryCache.find(queryKey, filters)) == null ? void 0 : _this$queryCache$find.state.data;
+  }
+
+  ensureQueryData(arg1, arg2, arg3) {
+    const parsedOptions = parseQueryArgs(arg1, arg2, arg3);
+    const cachedData = this.getQueryData(parsedOptions.queryKey);
+    return cachedData ? Promise.resolve(cachedData) : this.fetchQuery(parsedOptions);
+  }
+
+  getQueriesData(queryKeyOrFilters) {
+    return this.getQueryCache().findAll(queryKeyOrFilters).map(({
+      queryKey,
+      state
+    }) => {
+      const data = state.data;
+      return [queryKey, data];
+    });
+  }
+
+  setQueryData(queryKey, updater, options) {
+    const query = this.queryCache.find(queryKey);
+    const prevData = query == null ? void 0 : query.state.data;
+    const data = functionalUpdate(updater, prevData);
+
+    if (typeof data === 'undefined') {
+      return undefined;
+    }
+
+    const parsedOptions = parseQueryArgs(queryKey);
+    const defaultedOptions = this.defaultQueryOptions(parsedOptions);
+    return this.queryCache.build(this, defaultedOptions).setData(data, { ...options,
+      manual: true
+    });
+  }
+
+  setQueriesData(queryKeyOrFilters, updater, options) {
+    return notifyManager.batch(() => this.getQueryCache().findAll(queryKeyOrFilters).map(({
+      queryKey
+    }) => [queryKey, this.setQueryData(queryKey, updater, options)]));
+  }
+
+  getQueryState(queryKey, filters) {
+    var _this$queryCache$find2;
+
+    return (_this$queryCache$find2 = this.queryCache.find(queryKey, filters)) == null ? void 0 : _this$queryCache$find2.state;
+  }
+
+  removeQueries(arg1, arg2) {
+    const [filters] = parseFilterArgs(arg1, arg2);
+    const queryCache = this.queryCache;
+    notifyManager.batch(() => {
+      queryCache.findAll(filters).forEach(query => {
+        queryCache.remove(query);
+      });
+    });
+  }
+
+  resetQueries(arg1, arg2, arg3) {
+    const [filters, options] = parseFilterArgs(arg1, arg2, arg3);
+    const queryCache = this.queryCache;
+    const refetchFilters = {
+      type: 'active',
+      ...filters
+    };
+    return notifyManager.batch(() => {
+      queryCache.findAll(filters).forEach(query => {
+        query.reset();
+      });
+      return this.refetchQueries(refetchFilters, options);
+    });
+  }
+
+  cancelQueries(arg1, arg2, arg3) {
+    const [filters, cancelOptions = {}] = parseFilterArgs(arg1, arg2, arg3);
+
+    if (typeof cancelOptions.revert === 'undefined') {
+      cancelOptions.revert = true;
+    }
+
+    const promises = notifyManager.batch(() => this.queryCache.findAll(filters).map(query => query.cancel(cancelOptions)));
+    return Promise.all(promises).then(noop$1).catch(noop$1);
+  }
+
+  invalidateQueries(arg1, arg2, arg3) {
+    const [filters, options] = parseFilterArgs(arg1, arg2, arg3);
+    return notifyManager.batch(() => {
+      var _ref, _filters$refetchType;
+
+      this.queryCache.findAll(filters).forEach(query => {
+        query.invalidate();
+      });
+
+      if (filters.refetchType === 'none') {
+        return Promise.resolve();
+      }
+
+      const refetchFilters = { ...filters,
+        type: (_ref = (_filters$refetchType = filters.refetchType) != null ? _filters$refetchType : filters.type) != null ? _ref : 'active'
+      };
+      return this.refetchQueries(refetchFilters, options);
+    });
+  }
+
+  refetchQueries(arg1, arg2, arg3) {
+    const [filters, options] = parseFilterArgs(arg1, arg2, arg3);
+    const promises = notifyManager.batch(() => this.queryCache.findAll(filters).filter(query => !query.isDisabled()).map(query => {
+      var _options$cancelRefetc;
+
+      return query.fetch(undefined, { ...options,
+        cancelRefetch: (_options$cancelRefetc = options == null ? void 0 : options.cancelRefetch) != null ? _options$cancelRefetc : true,
+        meta: {
+          refetchPage: filters.refetchPage
+        }
+      });
+    }));
+    let promise = Promise.all(promises).then(noop$1);
+
+    if (!(options != null && options.throwOnError)) {
+      promise = promise.catch(noop$1);
+    }
+
+    return promise;
+  }
+
+  fetchQuery(arg1, arg2, arg3) {
+    const parsedOptions = parseQueryArgs(arg1, arg2, arg3);
+    const defaultedOptions = this.defaultQueryOptions(parsedOptions); // https://github.com/tannerlinsley/react-query/issues/652
+
+    if (typeof defaultedOptions.retry === 'undefined') {
+      defaultedOptions.retry = false;
+    }
+
+    const query = this.queryCache.build(this, defaultedOptions);
+    return query.isStaleByTime(defaultedOptions.staleTime) ? query.fetch(defaultedOptions) : Promise.resolve(query.state.data);
+  }
+
+  prefetchQuery(arg1, arg2, arg3) {
+    return this.fetchQuery(arg1, arg2, arg3).then(noop$1).catch(noop$1);
+  }
+
+  fetchInfiniteQuery(arg1, arg2, arg3) {
+    const parsedOptions = parseQueryArgs(arg1, arg2, arg3);
+    parsedOptions.behavior = infiniteQueryBehavior();
+    return this.fetchQuery(parsedOptions);
+  }
+
+  prefetchInfiniteQuery(arg1, arg2, arg3) {
+    return this.fetchInfiniteQuery(arg1, arg2, arg3).then(noop$1).catch(noop$1);
+  }
+
+  resumePausedMutations() {
+    return this.mutationCache.resumePausedMutations();
+  }
+
+  getQueryCache() {
+    return this.queryCache;
+  }
+
+  getMutationCache() {
+    return this.mutationCache;
+  }
+
+  getLogger() {
+    return this.logger;
+  }
+
+  getDefaultOptions() {
+    return this.defaultOptions;
+  }
+
+  setDefaultOptions(options) {
+    this.defaultOptions = options;
+  }
+
+  setQueryDefaults(queryKey, options) {
+    const result = this.queryDefaults.find(x => hashQueryKey(queryKey) === hashQueryKey(x.queryKey));
+
+    if (result) {
+      result.defaultOptions = options;
+    } else {
+      this.queryDefaults.push({
+        queryKey,
+        defaultOptions: options
+      });
+    }
+  }
+
+  getQueryDefaults(queryKey) {
+    if (!queryKey) {
+      return undefined;
+    } // Get the first matching defaults
+
+
+    const firstMatchingDefaults = this.queryDefaults.find(x => partialMatchKey(queryKey, x.queryKey)); // Additional checks and error in dev mode
+
+    if (process.env.NODE_ENV !== 'production') {
+      // Retrieve all matching defaults for the given key
+      const matchingDefaults = this.queryDefaults.filter(x => partialMatchKey(queryKey, x.queryKey)); // It is ok not having defaults, but it is error prone to have more than 1 default for a given key
+
+      if (matchingDefaults.length > 1) {
+        this.logger.error("[QueryClient] Several query defaults match with key '" + JSON.stringify(queryKey) + "'. The first matching query defaults are used. Please check how query defaults are registered. Order does matter here. cf. https://react-query.tanstack.com/reference/QueryClient#queryclientsetquerydefaults.");
+      }
+    }
+
+    return firstMatchingDefaults == null ? void 0 : firstMatchingDefaults.defaultOptions;
+  }
+
+  setMutationDefaults(mutationKey, options) {
+    const result = this.mutationDefaults.find(x => hashQueryKey(mutationKey) === hashQueryKey(x.mutationKey));
+
+    if (result) {
+      result.defaultOptions = options;
+    } else {
+      this.mutationDefaults.push({
+        mutationKey,
+        defaultOptions: options
+      });
+    }
+  }
+
+  getMutationDefaults(mutationKey) {
+    if (!mutationKey) {
+      return undefined;
+    } // Get the first matching defaults
+
+
+    const firstMatchingDefaults = this.mutationDefaults.find(x => partialMatchKey(mutationKey, x.mutationKey)); // Additional checks and error in dev mode
+
+    if (process.env.NODE_ENV !== 'production') {
+      // Retrieve all matching defaults for the given key
+      const matchingDefaults = this.mutationDefaults.filter(x => partialMatchKey(mutationKey, x.mutationKey)); // It is ok not having defaults, but it is error prone to have more than 1 default for a given key
+
+      if (matchingDefaults.length > 1) {
+        this.logger.error("[QueryClient] Several mutation defaults match with key '" + JSON.stringify(mutationKey) + "'. The first matching mutation defaults are used. Please check how mutation defaults are registered. Order does matter here. cf. https://react-query.tanstack.com/reference/QueryClient#queryclientsetmutationdefaults.");
+      }
+    }
+
+    return firstMatchingDefaults == null ? void 0 : firstMatchingDefaults.defaultOptions;
+  }
+
+  defaultQueryOptions(options) {
+    if (options != null && options._defaulted) {
+      return options;
+    }
+
+    const defaultedOptions = { ...this.defaultOptions.queries,
+      ...this.getQueryDefaults(options == null ? void 0 : options.queryKey),
+      ...options,
+      _defaulted: true
+    };
+
+    if (!defaultedOptions.queryHash && defaultedOptions.queryKey) {
+      defaultedOptions.queryHash = hashQueryKeyByOptions(defaultedOptions.queryKey, defaultedOptions);
+    } // dependent default values
+
+
+    if (typeof defaultedOptions.refetchOnReconnect === 'undefined') {
+      defaultedOptions.refetchOnReconnect = defaultedOptions.networkMode !== 'always';
+    }
+
+    if (typeof defaultedOptions.useErrorBoundary === 'undefined') {
+      defaultedOptions.useErrorBoundary = !!defaultedOptions.suspense;
+    }
+
+    return defaultedOptions;
+  }
+
+  defaultMutationOptions(options) {
+    if (options != null && options._defaulted) {
+      return options;
+    }
+
+    return { ...this.defaultOptions.mutations,
+      ...this.getMutationDefaults(options == null ? void 0 : options.mutationKey),
+      ...options,
+      _defaulted: true
+    };
+  }
+
+  clear() {
+    this.queryCache.clear();
+    this.mutationCache.clear();
+  }
+
+}
+
+class QueryObserver extends Subscribable {
+  constructor(client, options) {
+    super();
+    this.client = client;
+    this.options = options;
+    this.trackedProps = new Set();
+    this.selectError = null;
+    this.bindMethods();
+    this.setOptions(options);
+  }
+
+  bindMethods() {
+    this.remove = this.remove.bind(this);
+    this.refetch = this.refetch.bind(this);
+  }
+
+  onSubscribe() {
+    if (this.listeners.size === 1) {
+      this.currentQuery.addObserver(this);
+
+      if (shouldFetchOnMount(this.currentQuery, this.options)) {
+        this.executeFetch();
+      }
+
+      this.updateTimers();
+    }
+  }
+
+  onUnsubscribe() {
+    if (!this.hasListeners()) {
+      this.destroy();
+    }
+  }
+
+  shouldFetchOnReconnect() {
+    return shouldFetchOn(this.currentQuery, this.options, this.options.refetchOnReconnect);
+  }
+
+  shouldFetchOnWindowFocus() {
+    return shouldFetchOn(this.currentQuery, this.options, this.options.refetchOnWindowFocus);
+  }
+
+  destroy() {
+    this.listeners = new Set();
+    this.clearStaleTimeout();
+    this.clearRefetchInterval();
+    this.currentQuery.removeObserver(this);
+  }
+
+  setOptions(options, notifyOptions) {
+    const prevOptions = this.options;
+    const prevQuery = this.currentQuery;
+    this.options = this.client.defaultQueryOptions(options);
+
+    if (process.env.NODE_ENV !== 'production' && typeof (options == null ? void 0 : options.isDataEqual) !== 'undefined') {
+      this.client.getLogger().error("The isDataEqual option has been deprecated and will be removed in the next major version. You can achieve the same functionality by passing a function as the structuralSharing option");
+    }
+
+    if (!shallowEqualObjects(prevOptions, this.options)) {
+      this.client.getQueryCache().notify({
+        type: 'observerOptionsUpdated',
+        query: this.currentQuery,
+        observer: this
+      });
+    }
+
+    if (typeof this.options.enabled !== 'undefined' && typeof this.options.enabled !== 'boolean') {
+      throw new Error('Expected enabled to be a boolean');
+    } // Keep previous query key if the user does not supply one
+
+
+    if (!this.options.queryKey) {
+      this.options.queryKey = prevOptions.queryKey;
+    }
+
+    this.updateQuery();
+    const mounted = this.hasListeners(); // Fetch if there are subscribers
+
+    if (mounted && shouldFetchOptionally(this.currentQuery, prevQuery, this.options, prevOptions)) {
+      this.executeFetch();
+    } // Update result
+
+
+    this.updateResult(notifyOptions); // Update stale interval if needed
+
+    if (mounted && (this.currentQuery !== prevQuery || this.options.enabled !== prevOptions.enabled || this.options.staleTime !== prevOptions.staleTime)) {
+      this.updateStaleTimeout();
+    }
+
+    const nextRefetchInterval = this.computeRefetchInterval(); // Update refetch interval if needed
+
+    if (mounted && (this.currentQuery !== prevQuery || this.options.enabled !== prevOptions.enabled || nextRefetchInterval !== this.currentRefetchInterval)) {
+      this.updateRefetchInterval(nextRefetchInterval);
+    }
+  }
+
+  getOptimisticResult(options) {
+    const query = this.client.getQueryCache().build(this.client, options);
+    const result = this.createResult(query, options);
+
+    if (shouldAssignObserverCurrentProperties(this, result, options)) {
+      // this assigns the optimistic result to the current Observer
+      // because if the query function changes, useQuery will be performing
+      // an effect where it would fetch again.
+      // When the fetch finishes, we perform a deep data cloning in order
+      // to reuse objects references. This deep data clone is performed against
+      // the `observer.currentResult.data` property
+      // When QueryKey changes, we refresh the query and get new `optimistic`
+      // result, while we leave the `observer.currentResult`, so when new data
+      // arrives, it finds the old `observer.currentResult` which is related
+      // to the old QueryKey. Which means that currentResult and selectData are
+      // out of sync already.
+      // To solve this, we move the cursor of the currentResult everytime
+      // an observer reads an optimistic value.
+      // When keeping the previous data, the result doesn't change until new
+      // data arrives.
+      this.currentResult = result;
+      this.currentResultOptions = this.options;
+      this.currentResultState = this.currentQuery.state;
+    }
+
+    return result;
+  }
+
+  getCurrentResult() {
+    return this.currentResult;
+  }
+
+  trackResult(result) {
+    const trackedResult = {};
+    Object.keys(result).forEach(key => {
+      Object.defineProperty(trackedResult, key, {
+        configurable: false,
+        enumerable: true,
+        get: () => {
+          this.trackedProps.add(key);
+          return result[key];
+        }
+      });
+    });
+    return trackedResult;
+  }
+
+  getCurrentQuery() {
+    return this.currentQuery;
+  }
+
+  remove() {
+    this.client.getQueryCache().remove(this.currentQuery);
+  }
+
+  refetch({
+    refetchPage,
+    ...options
+  } = {}) {
+    return this.fetch({ ...options,
+      meta: {
+        refetchPage
+      }
+    });
+  }
+
+  fetchOptimistic(options) {
+    const defaultedOptions = this.client.defaultQueryOptions(options);
+    const query = this.client.getQueryCache().build(this.client, defaultedOptions);
+    query.isFetchingOptimistic = true;
+    return query.fetch().then(() => this.createResult(query, defaultedOptions));
+  }
+
+  fetch(fetchOptions) {
+    var _fetchOptions$cancelR;
+
+    return this.executeFetch({ ...fetchOptions,
+      cancelRefetch: (_fetchOptions$cancelR = fetchOptions.cancelRefetch) != null ? _fetchOptions$cancelR : true
+    }).then(() => {
+      this.updateResult();
+      return this.currentResult;
+    });
+  }
+
+  executeFetch(fetchOptions) {
+    // Make sure we reference the latest query as the current one might have been removed
+    this.updateQuery(); // Fetch
+
+    let promise = this.currentQuery.fetch(this.options, fetchOptions);
+
+    if (!(fetchOptions != null && fetchOptions.throwOnError)) {
+      promise = promise.catch(noop$1);
+    }
+
+    return promise;
+  }
+
+  updateStaleTimeout() {
+    this.clearStaleTimeout();
+
+    if (isServer || this.currentResult.isStale || !isValidTimeout(this.options.staleTime)) {
+      return;
+    }
+
+    const time = timeUntilStale(this.currentResult.dataUpdatedAt, this.options.staleTime); // The timeout is sometimes triggered 1 ms before the stale time expiration.
+    // To mitigate this issue we always add 1 ms to the timeout.
+
+    const timeout = time + 1;
+    this.staleTimeoutId = setTimeout(() => {
+      if (!this.currentResult.isStale) {
+        this.updateResult();
+      }
+    }, timeout);
+  }
+
+  computeRefetchInterval() {
+    var _this$options$refetch;
+
+    return typeof this.options.refetchInterval === 'function' ? this.options.refetchInterval(this.currentResult.data, this.currentQuery) : (_this$options$refetch = this.options.refetchInterval) != null ? _this$options$refetch : false;
+  }
+
+  updateRefetchInterval(nextInterval) {
+    this.clearRefetchInterval();
+    this.currentRefetchInterval = nextInterval;
+
+    if (isServer || this.options.enabled === false || !isValidTimeout(this.currentRefetchInterval) || this.currentRefetchInterval === 0) {
+      return;
+    }
+
+    this.refetchIntervalId = setInterval(() => {
+      if (this.options.refetchIntervalInBackground || focusManager.isFocused()) {
+        this.executeFetch();
+      }
+    }, this.currentRefetchInterval);
+  }
+
+  updateTimers() {
+    this.updateStaleTimeout();
+    this.updateRefetchInterval(this.computeRefetchInterval());
+  }
+
+  clearStaleTimeout() {
+    if (this.staleTimeoutId) {
+      clearTimeout(this.staleTimeoutId);
+      this.staleTimeoutId = undefined;
+    }
+  }
+
+  clearRefetchInterval() {
+    if (this.refetchIntervalId) {
+      clearInterval(this.refetchIntervalId);
+      this.refetchIntervalId = undefined;
+    }
+  }
+
+  createResult(query, options) {
+    const prevQuery = this.currentQuery;
+    const prevOptions = this.options;
+    const prevResult = this.currentResult;
+    const prevResultState = this.currentResultState;
+    const prevResultOptions = this.currentResultOptions;
+    const queryChange = query !== prevQuery;
+    const queryInitialState = queryChange ? query.state : this.currentQueryInitialState;
+    const prevQueryResult = queryChange ? this.currentResult : this.previousQueryResult;
+    const {
+      state
+    } = query;
+    let {
+      dataUpdatedAt,
+      error,
+      errorUpdatedAt,
+      fetchStatus,
+      status
+    } = state;
+    let isPreviousData = false;
+    let isPlaceholderData = false;
+    let data; // Optimistically set result in fetching state if needed
+
+    if (options._optimisticResults) {
+      const mounted = this.hasListeners();
+      const fetchOnMount = !mounted && shouldFetchOnMount(query, options);
+      const fetchOptionally = mounted && shouldFetchOptionally(query, prevQuery, options, prevOptions);
+
+      if (fetchOnMount || fetchOptionally) {
+        fetchStatus = canFetch(query.options.networkMode) ? 'fetching' : 'paused';
+
+        if (!dataUpdatedAt) {
+          status = 'loading';
+        }
+      }
+
+      if (options._optimisticResults === 'isRestoring') {
+        fetchStatus = 'idle';
+      }
+    } // Keep previous data if needed
+
+
+    if (options.keepPreviousData && !state.dataUpdatedAt && prevQueryResult != null && prevQueryResult.isSuccess && status !== 'error') {
+      data = prevQueryResult.data;
+      dataUpdatedAt = prevQueryResult.dataUpdatedAt;
+      status = prevQueryResult.status;
+      isPreviousData = true;
+    } // Select data if needed
+    else if (options.select && typeof state.data !== 'undefined') {
+      // Memoize select result
+      if (prevResult && state.data === (prevResultState == null ? void 0 : prevResultState.data) && options.select === this.selectFn) {
+        data = this.selectResult;
+      } else {
+        try {
+          this.selectFn = options.select;
+          data = options.select(state.data);
+          data = replaceData(prevResult == null ? void 0 : prevResult.data, data, options);
+          this.selectResult = data;
+          this.selectError = null;
+        } catch (selectError) {
+          if (process.env.NODE_ENV !== 'production') {
+            this.client.getLogger().error(selectError);
+          }
+
+          this.selectError = selectError;
+        }
+      }
+    } // Use query data
+    else {
+      data = state.data;
+    } // Show placeholder data if needed
+
+
+    if (typeof options.placeholderData !== 'undefined' && typeof data === 'undefined' && status === 'loading') {
+      let placeholderData; // Memoize placeholder data
+
+      if (prevResult != null && prevResult.isPlaceholderData && options.placeholderData === (prevResultOptions == null ? void 0 : prevResultOptions.placeholderData)) {
+        placeholderData = prevResult.data;
+      } else {
+        placeholderData = typeof options.placeholderData === 'function' ? options.placeholderData() : options.placeholderData;
+
+        if (options.select && typeof placeholderData !== 'undefined') {
+          try {
+            placeholderData = options.select(placeholderData);
+            this.selectError = null;
+          } catch (selectError) {
+            if (process.env.NODE_ENV !== 'production') {
+              this.client.getLogger().error(selectError);
+            }
+
+            this.selectError = selectError;
+          }
+        }
+      }
+
+      if (typeof placeholderData !== 'undefined') {
+        status = 'success';
+        data = replaceData(prevResult == null ? void 0 : prevResult.data, placeholderData, options);
+        isPlaceholderData = true;
+      }
+    }
+
+    if (this.selectError) {
+      error = this.selectError;
+      data = this.selectResult;
+      errorUpdatedAt = Date.now();
+      status = 'error';
+    }
+
+    const isFetching = fetchStatus === 'fetching';
+    const isLoading = status === 'loading';
+    const isError = status === 'error';
+    const result = {
+      status,
+      fetchStatus,
+      isLoading,
+      isSuccess: status === 'success',
+      isError,
+      isInitialLoading: isLoading && isFetching,
+      data,
+      dataUpdatedAt,
+      error,
+      errorUpdatedAt,
+      failureCount: state.fetchFailureCount,
+      failureReason: state.fetchFailureReason,
+      errorUpdateCount: state.errorUpdateCount,
+      isFetched: state.dataUpdateCount > 0 || state.errorUpdateCount > 0,
+      isFetchedAfterMount: state.dataUpdateCount > queryInitialState.dataUpdateCount || state.errorUpdateCount > queryInitialState.errorUpdateCount,
+      isFetching,
+      isRefetching: isFetching && !isLoading,
+      isLoadingError: isError && state.dataUpdatedAt === 0,
+      isPaused: fetchStatus === 'paused',
+      isPlaceholderData,
+      isPreviousData,
+      isRefetchError: isError && state.dataUpdatedAt !== 0,
+      isStale: isStale(query, options),
+      refetch: this.refetch,
+      remove: this.remove
+    };
+    return result;
+  }
+
+  updateResult(notifyOptions) {
+    const prevResult = this.currentResult;
+    const nextResult = this.createResult(this.currentQuery, this.options);
+    this.currentResultState = this.currentQuery.state;
+    this.currentResultOptions = this.options; // Only notify and update result if something has changed
+
+    if (shallowEqualObjects(nextResult, prevResult)) {
+      return;
+    }
+
+    this.currentResult = nextResult; // Determine which callbacks to trigger
+
+    const defaultNotifyOptions = {
+      cache: true
+    };
+
+    const shouldNotifyListeners = () => {
+      if (!prevResult) {
+        return true;
+      }
+
+      const {
+        notifyOnChangeProps
+      } = this.options;
+      const notifyOnChangePropsValue = typeof notifyOnChangeProps === 'function' ? notifyOnChangeProps() : notifyOnChangeProps;
+
+      if (notifyOnChangePropsValue === 'all' || !notifyOnChangePropsValue && !this.trackedProps.size) {
+        return true;
+      }
+
+      const includedProps = new Set(notifyOnChangePropsValue != null ? notifyOnChangePropsValue : this.trackedProps);
+
+      if (this.options.useErrorBoundary) {
+        includedProps.add('error');
+      }
+
+      return Object.keys(this.currentResult).some(key => {
+        const typedKey = key;
+        const changed = this.currentResult[typedKey] !== prevResult[typedKey];
+        return changed && includedProps.has(typedKey);
+      });
+    };
+
+    if ((notifyOptions == null ? void 0 : notifyOptions.listeners) !== false && shouldNotifyListeners()) {
+      defaultNotifyOptions.listeners = true;
+    }
+
+    this.notify({ ...defaultNotifyOptions,
+      ...notifyOptions
+    });
+  }
+
+  updateQuery() {
+    const query = this.client.getQueryCache().build(this.client, this.options);
+
+    if (query === this.currentQuery) {
+      return;
+    }
+
+    const prevQuery = this.currentQuery;
+    this.currentQuery = query;
+    this.currentQueryInitialState = query.state;
+    this.previousQueryResult = this.currentResult;
+
+    if (this.hasListeners()) {
+      prevQuery == null ? void 0 : prevQuery.removeObserver(this);
+      query.addObserver(this);
+    }
+  }
+
+  onQueryUpdate(action) {
+    const notifyOptions = {};
+
+    if (action.type === 'success') {
+      notifyOptions.onSuccess = !action.manual;
+    } else if (action.type === 'error' && !isCancelledError(action.error)) {
+      notifyOptions.onError = true;
+    }
+
+    this.updateResult(notifyOptions);
+
+    if (this.hasListeners()) {
+      this.updateTimers();
+    }
+  }
+
+  notify(notifyOptions) {
+    notifyManager.batch(() => {
+      // First trigger the configuration callbacks
+      if (notifyOptions.onSuccess) {
+        var _this$options$onSucce, _this$options, _this$options$onSettl, _this$options2;
+
+        (_this$options$onSucce = (_this$options = this.options).onSuccess) == null ? void 0 : _this$options$onSucce.call(_this$options, this.currentResult.data);
+        (_this$options$onSettl = (_this$options2 = this.options).onSettled) == null ? void 0 : _this$options$onSettl.call(_this$options2, this.currentResult.data, null);
+      } else if (notifyOptions.onError) {
+        var _this$options$onError, _this$options3, _this$options$onSettl2, _this$options4;
+
+        (_this$options$onError = (_this$options3 = this.options).onError) == null ? void 0 : _this$options$onError.call(_this$options3, this.currentResult.error);
+        (_this$options$onSettl2 = (_this$options4 = this.options).onSettled) == null ? void 0 : _this$options$onSettl2.call(_this$options4, undefined, this.currentResult.error);
+      } // Then trigger the listeners
+
+
+      if (notifyOptions.listeners) {
+        this.listeners.forEach(({
+          listener
+        }) => {
+          listener(this.currentResult);
+        });
+      } // Then the cache listeners
+
+
+      if (notifyOptions.cache) {
+        this.client.getQueryCache().notify({
+          query: this.currentQuery,
+          type: 'observerResultsUpdated'
+        });
+      }
+    });
+  }
+
+}
+
+function shouldLoadOnMount(query, options) {
+  return options.enabled !== false && !query.state.dataUpdatedAt && !(query.state.status === 'error' && options.retryOnMount === false);
+}
+
+function shouldFetchOnMount(query, options) {
+  return shouldLoadOnMount(query, options) || query.state.dataUpdatedAt > 0 && shouldFetchOn(query, options, options.refetchOnMount);
+}
+
+function shouldFetchOn(query, options, field) {
+  if (options.enabled !== false) {
+    const value = typeof field === 'function' ? field(query) : field;
+    return value === 'always' || value !== false && isStale(query, options);
+  }
+
+  return false;
+}
+
+function shouldFetchOptionally(query, prevQuery, options, prevOptions) {
+  return options.enabled !== false && (query !== prevQuery || prevOptions.enabled === false) && (!options.suspense || query.state.status !== 'error') && isStale(query, options);
+}
+
+function isStale(query, options) {
+  return query.isStaleByTime(options.staleTime);
+} // this function would decide if we will update the observer's 'current'
+// properties after an optimistic reading via getOptimisticResult
+
+
+function shouldAssignObserverCurrentProperties(observer, optimisticResult, options) {
+  // it is important to keep this condition like this for three reasons:
+  // 1. It will get removed in the v5
+  // 2. it reads: don't update the properties if we want to keep the previous
+  // data.
+  // 3. The opposite condition (!options.keepPreviousData) would fallthrough
+  // and will result in a bad decision
+  if (options.keepPreviousData) {
+    return false;
+  } // this means we want to put some placeholder data when pending and queryKey
+  // changed.
+
+
+  if (options.placeholderData !== undefined) {
+    // re-assign properties only if current data is placeholder data
+    // which means that data did not arrive yet, so, if there is some cached data
+    // we need to "prepare" to receive it
+    return optimisticResult.isPlaceholderData;
+  } // if the newly created result isn't what the observer is holding as current,
+  // then we'll need to update the properties as well
+
+
+  if (!shallowEqualObjects(observer.getCurrentResult(), optimisticResult)) {
+    return true;
+  } // basically, just keep previous properties if nothing changed
+
+
+  return false;
+}
+
+class QueriesObserver extends Subscribable {
+  constructor(client, queries) {
+    super();
+    this.client = client;
+    this.queries = [];
+    this.result = [];
+    this.observers = [];
+    this.observersMap = {};
+
+    if (queries) {
+      this.setQueries(queries);
+    }
+  }
+
+  onSubscribe() {
+    if (this.listeners.size === 1) {
+      this.observers.forEach(observer => {
+        observer.subscribe(result => {
+          this.onUpdate(observer, result);
+        });
+      });
+    }
+  }
+
+  onUnsubscribe() {
+    if (!this.listeners.size) {
+      this.destroy();
+    }
+  }
+
+  destroy() {
+    this.listeners = new Set();
+    this.observers.forEach(observer => {
+      observer.destroy();
+    });
+  }
+
+  setQueries(queries, notifyOptions) {
+    this.queries = queries;
+    notifyManager.batch(() => {
+      const prevObservers = this.observers;
+      const newObserverMatches = this.findMatchingObservers(this.queries); // set options for the new observers to notify of changes
+
+      newObserverMatches.forEach(match => match.observer.setOptions(match.defaultedQueryOptions, notifyOptions));
+      const newObservers = newObserverMatches.map(match => match.observer);
+      const newObserversMap = Object.fromEntries(newObservers.map(observer => [observer.options.queryHash, observer]));
+      const newResult = newObservers.map(observer => observer.getCurrentResult());
+      const hasIndexChange = newObservers.some((observer, index) => observer !== prevObservers[index]);
+
+      if (prevObservers.length === newObservers.length && !hasIndexChange) {
+        return;
+      }
+
+      this.observers = newObservers;
+      this.observersMap = newObserversMap;
+      this.result = newResult;
+
+      if (!this.hasListeners()) {
+        return;
+      }
+
+      difference(prevObservers, newObservers).forEach(observer => {
+        observer.destroy();
+      });
+      difference(newObservers, prevObservers).forEach(observer => {
+        observer.subscribe(result => {
+          this.onUpdate(observer, result);
+        });
+      });
+      this.notify();
+    });
+  }
+
+  getCurrentResult() {
+    return this.result;
+  }
+
+  getQueries() {
+    return this.observers.map(observer => observer.getCurrentQuery());
+  }
+
+  getObservers() {
+    return this.observers;
+  }
+
+  getOptimisticResult(queries) {
+    return this.findMatchingObservers(queries).map(match => match.observer.getOptimisticResult(match.defaultedQueryOptions));
+  }
+
+  findMatchingObservers(queries) {
+    const prevObservers = this.observers;
+    const prevObserversMap = new Map(prevObservers.map(observer => [observer.options.queryHash, observer]));
+    const defaultedQueryOptions = queries.map(options => this.client.defaultQueryOptions(options));
+    const matchingObservers = defaultedQueryOptions.flatMap(defaultedOptions => {
+      const match = prevObserversMap.get(defaultedOptions.queryHash);
+
+      if (match != null) {
+        return [{
+          defaultedQueryOptions: defaultedOptions,
+          observer: match
+        }];
+      }
+
+      return [];
+    });
+    const matchedQueryHashes = new Set(matchingObservers.map(match => match.defaultedQueryOptions.queryHash));
+    const unmatchedQueries = defaultedQueryOptions.filter(defaultedOptions => !matchedQueryHashes.has(defaultedOptions.queryHash));
+    const matchingObserversSet = new Set(matchingObservers.map(match => match.observer));
+    const unmatchedObservers = prevObservers.filter(prevObserver => !matchingObserversSet.has(prevObserver));
+
+    const getObserver = options => {
+      const defaultedOptions = this.client.defaultQueryOptions(options);
+      const currentObserver = this.observersMap[defaultedOptions.queryHash];
+      return currentObserver != null ? currentObserver : new QueryObserver(this.client, defaultedOptions);
+    };
+
+    const newOrReusedObservers = unmatchedQueries.map((options, index) => {
+      if (options.keepPreviousData) {
+        // return previous data from one of the observers that no longer match
+        const previouslyUsedObserver = unmatchedObservers[index];
+
+        if (previouslyUsedObserver !== undefined) {
+          return {
+            defaultedQueryOptions: options,
+            observer: previouslyUsedObserver
+          };
+        }
+      }
+
+      return {
+        defaultedQueryOptions: options,
+        observer: getObserver(options)
+      };
+    });
+
+    const sortMatchesByOrderOfQueries = (a, b) => defaultedQueryOptions.indexOf(a.defaultedQueryOptions) - defaultedQueryOptions.indexOf(b.defaultedQueryOptions);
+
+    return matchingObservers.concat(newOrReusedObservers).sort(sortMatchesByOrderOfQueries);
+  }
+
+  onUpdate(observer, result) {
+    const index = this.observers.indexOf(observer);
+
+    if (index !== -1) {
+      this.result = replaceAt(this.result, index, result);
+      this.notify();
+    }
+  }
+
+  notify() {
+    notifyManager.batch(() => {
+      this.listeners.forEach(({
+        listener
+      }) => {
+        listener(this.result);
+      });
+    });
+  }
+
+}
+
+// CLASS
+class MutationObserver extends Subscribable {
+  constructor(client, options) {
+    super();
+    this.client = client;
+    this.setOptions(options);
+    this.bindMethods();
+    this.updateResult();
+  }
+
+  bindMethods() {
+    this.mutate = this.mutate.bind(this);
+    this.reset = this.reset.bind(this);
+  }
+
+  setOptions(options) {
+    var _this$currentMutation;
+
+    const prevOptions = this.options;
+    this.options = this.client.defaultMutationOptions(options);
+
+    if (!shallowEqualObjects(prevOptions, this.options)) {
+      this.client.getMutationCache().notify({
+        type: 'observerOptionsUpdated',
+        mutation: this.currentMutation,
+        observer: this
+      });
+    }
+
+    (_this$currentMutation = this.currentMutation) == null ? void 0 : _this$currentMutation.setOptions(this.options);
+  }
+
+  onUnsubscribe() {
+    if (!this.hasListeners()) {
+      var _this$currentMutation2;
+
+      (_this$currentMutation2 = this.currentMutation) == null ? void 0 : _this$currentMutation2.removeObserver(this);
+    }
+  }
+
+  onMutationUpdate(action) {
+    this.updateResult(); // Determine which callbacks to trigger
+
+    const notifyOptions = {
+      listeners: true
+    };
+
+    if (action.type === 'success') {
+      notifyOptions.onSuccess = true;
+    } else if (action.type === 'error') {
+      notifyOptions.onError = true;
+    }
+
+    this.notify(notifyOptions);
+  }
+
+  getCurrentResult() {
+    return this.currentResult;
+  }
+
+  reset() {
+    this.currentMutation = undefined;
+    this.updateResult();
+    this.notify({
+      listeners: true
+    });
+  }
+
+  mutate(variables, options) {
+    this.mutateOptions = options;
+
+    if (this.currentMutation) {
+      this.currentMutation.removeObserver(this);
     }
+
+    this.currentMutation = this.client.getMutationCache().build(this.client, { ...this.options,
+      variables: typeof variables !== 'undefined' ? variables : this.options.variables
+    });
+    this.currentMutation.addObserver(this);
+    return this.currentMutation.execute();
+  }
+
+  updateResult() {
+    const state = this.currentMutation ? this.currentMutation.state : getDefaultState();
+    const result = { ...state,
+      isLoading: state.status === 'loading',
+      isSuccess: state.status === 'success',
+      isError: state.status === 'error',
+      isIdle: state.status === 'idle',
+      mutate: this.mutate,
+      reset: this.reset
+    };
+    this.currentResult = result;
+  }
+
+  notify(options) {
+    notifyManager.batch(() => {
+      // First trigger the mutate callbacks
+      if (this.mutateOptions && this.hasListeners()) {
+        if (options.onSuccess) {
+          var _this$mutateOptions$o, _this$mutateOptions, _this$mutateOptions$o2, _this$mutateOptions2;
+
+          (_this$mutateOptions$o = (_this$mutateOptions = this.mutateOptions).onSuccess) == null ? void 0 : _this$mutateOptions$o.call(_this$mutateOptions, this.currentResult.data, this.currentResult.variables, this.currentResult.context);
+          (_this$mutateOptions$o2 = (_this$mutateOptions2 = this.mutateOptions).onSettled) == null ? void 0 : _this$mutateOptions$o2.call(_this$mutateOptions2, this.currentResult.data, null, this.currentResult.variables, this.currentResult.context);
+        } else if (options.onError) {
+          var _this$mutateOptions$o3, _this$mutateOptions3, _this$mutateOptions$o4, _this$mutateOptions4;
+
+          (_this$mutateOptions$o3 = (_this$mutateOptions3 = this.mutateOptions).onError) == null ? void 0 : _this$mutateOptions$o3.call(_this$mutateOptions3, this.currentResult.error, this.currentResult.variables, this.currentResult.context);
+          (_this$mutateOptions$o4 = (_this$mutateOptions4 = this.mutateOptions).onSettled) == null ? void 0 : _this$mutateOptions$o4.call(_this$mutateOptions4, undefined, this.currentResult.error, this.currentResult.variables, this.currentResult.context);
+        }
+      } // Then trigger the listeners
+
+
+      if (options.listeners) {
+        this.listeners.forEach(({
+          listener
+        }) => {
+          listener(this.currentResult);
+        });
+      }
+    });
+  }
+
 }
 
 var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
@@ -270,6 +3301,603 @@ function getAugmentedNamespace(n) {
 	return a;
 }
 
+var shim = {exports: {}};
+
+var useSyncExternalStoreShim_production_min = {};
+
+var require$$0$3 = /*@__PURE__*/getAugmentedNamespace(React__namespace);
+
+/**
+ * @license React
+ * use-sync-external-store-shim.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+var hasRequiredUseSyncExternalStoreShim_production_min;
+
+function requireUseSyncExternalStoreShim_production_min () {
+	if (hasRequiredUseSyncExternalStoreShim_production_min) return useSyncExternalStoreShim_production_min;
+	hasRequiredUseSyncExternalStoreShim_production_min = 1;
+var e=require$$0$3;function h(a,b){return a===b&&(0!==a||1/a===1/b)||a!==a&&b!==b}var k="function"===typeof Object.is?Object.is:h,l=e.useState,m=e.useEffect,n=e.useLayoutEffect,p=e.useDebugValue;function q(a,b){var d=b(),f=l({inst:{value:d,getSnapshot:b}}),c=f[0].inst,g=f[1];n(function(){c.value=d;c.getSnapshot=b;r(c)&&g({inst:c});},[a,d,b]);m(function(){r(c)&&g({inst:c});return a(function(){r(c)&&g({inst:c});})},[a]);p(d);return d}
+	function r(a){var b=a.getSnapshot;a=a.value;try{var d=b();return !k(a,d)}catch(f){return  true}}function t(a,b){return b()}var u="undefined"===typeof window||"undefined"===typeof window.document||"undefined"===typeof window.document.createElement?t:q;useSyncExternalStoreShim_production_min.useSyncExternalStore=void 0!==e.useSyncExternalStore?e.useSyncExternalStore:u;
+	return useSyncExternalStoreShim_production_min;
+}
+
+var useSyncExternalStoreShim_development = {};
+
+/**
+ * @license React
+ * use-sync-external-store-shim.development.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+var hasRequiredUseSyncExternalStoreShim_development;
+
+function requireUseSyncExternalStoreShim_development () {
+	if (hasRequiredUseSyncExternalStoreShim_development) return useSyncExternalStoreShim_development;
+	hasRequiredUseSyncExternalStoreShim_development = 1;
+
+	if (process.env.NODE_ENV !== "production") {
+	  (function() {
+
+	/* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */
+	if (
+	  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' &&
+	  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart ===
+	    'function'
+	) {
+	  __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(new Error());
+	}
+	          var React = require$$0$3;
+
+	var ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+	function error(format) {
+	  {
+	    {
+	      for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+	        args[_key2 - 1] = arguments[_key2];
+	      }
+
+	      printWarning('error', format, args);
+	    }
+	  }
+	}
+
+	function printWarning(level, format, args) {
+	  // When changing this logic, you might want to also
+	  // update consoleWithStackDev.www.js as well.
+	  {
+	    var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
+	    var stack = ReactDebugCurrentFrame.getStackAddendum();
+
+	    if (stack !== '') {
+	      format += '%s';
+	      args = args.concat([stack]);
+	    } // eslint-disable-next-line react-internal/safe-string-coercion
+
+
+	    var argsWithFormat = args.map(function (item) {
+	      return String(item);
+	    }); // Careful: RN currently depends on this prefix
+
+	    argsWithFormat.unshift('Warning: ' + format); // We intentionally don't use spread (or .apply) directly because it
+	    // breaks IE9: https://github.com/facebook/react/issues/13610
+	    // eslint-disable-next-line react-internal/no-production-logging
+
+	    Function.prototype.apply.call(console[level], console, argsWithFormat);
+	  }
+	}
+
+	/**
+	 * inlined Object.is polyfill to avoid requiring consumers ship their own
+	 * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
+	 */
+	function is(x, y) {
+	  return x === y && (x !== 0 || 1 / x === 1 / y) || x !== x && y !== y // eslint-disable-line no-self-compare
+	  ;
+	}
+
+	var objectIs = typeof Object.is === 'function' ? Object.is : is;
+
+	// dispatch for CommonJS interop named imports.
+
+	var useState = React.useState,
+	    useEffect = React.useEffect,
+	    useLayoutEffect = React.useLayoutEffect,
+	    useDebugValue = React.useDebugValue;
+	var didWarnOld18Alpha = false;
+	var didWarnUncachedGetSnapshot = false; // Disclaimer: This shim breaks many of the rules of React, and only works
+	// because of a very particular set of implementation details and assumptions
+	// -- change any one of them and it will break. The most important assumption
+	// is that updates are always synchronous, because concurrent rendering is
+	// only available in versions of React that also have a built-in
+	// useSyncExternalStore API. And we only use this shim when the built-in API
+	// does not exist.
+	//
+	// Do not assume that the clever hacks used by this hook also work in general.
+	// The point of this shim is to replace the need for hacks by other libraries.
+
+	function useSyncExternalStore(subscribe, getSnapshot, // Note: The shim does not use getServerSnapshot, because pre-18 versions of
+	// React do not expose a way to check if we're hydrating. So users of the shim
+	// will need to track that themselves and return the correct value
+	// from `getSnapshot`.
+	getServerSnapshot) {
+	  {
+	    if (!didWarnOld18Alpha) {
+	      if (React.startTransition !== undefined) {
+	        didWarnOld18Alpha = true;
+
+	        error('You are using an outdated, pre-release alpha of React 18 that ' + 'does not support useSyncExternalStore. The ' + 'use-sync-external-store shim will not work correctly. Upgrade ' + 'to a newer pre-release.');
+	      }
+	    }
+	  } // Read the current snapshot from the store on every render. Again, this
+	  // breaks the rules of React, and only works here because of specific
+	  // implementation details, most importantly that updates are
+	  // always synchronous.
+
+
+	  var value = getSnapshot();
+
+	  {
+	    if (!didWarnUncachedGetSnapshot) {
+	      var cachedValue = getSnapshot();
+
+	      if (!objectIs(value, cachedValue)) {
+	        error('The result of getSnapshot should be cached to avoid an infinite loop');
+
+	        didWarnUncachedGetSnapshot = true;
+	      }
+	    }
+	  } // Because updates are synchronous, we don't queue them. Instead we force a
+	  // re-render whenever the subscribed state changes by updating an some
+	  // arbitrary useState hook. Then, during render, we call getSnapshot to read
+	  // the current value.
+	  //
+	  // Because we don't actually use the state returned by the useState hook, we
+	  // can save a bit of memory by storing other stuff in that slot.
+	  //
+	  // To implement the early bailout, we need to track some things on a mutable
+	  // object. Usually, we would put that in a useRef hook, but we can stash it in
+	  // our useState hook instead.
+	  //
+	  // To force a re-render, we call forceUpdate({inst}). That works because the
+	  // new object always fails an equality check.
+
+
+	  var _useState = useState({
+	    inst: {
+	      value: value,
+	      getSnapshot: getSnapshot
+	    }
+	  }),
+	      inst = _useState[0].inst,
+	      forceUpdate = _useState[1]; // Track the latest getSnapshot function with a ref. This needs to be updated
+	  // in the layout phase so we can access it during the tearing check that
+	  // happens on subscribe.
+
+
+	  useLayoutEffect(function () {
+	    inst.value = value;
+	    inst.getSnapshot = getSnapshot; // Whenever getSnapshot or subscribe changes, we need to check in the
+	    // commit phase if there was an interleaved mutation. In concurrent mode
+	    // this can happen all the time, but even in synchronous mode, an earlier
+	    // effect may have mutated the store.
+
+	    if (checkIfSnapshotChanged(inst)) {
+	      // Force a re-render.
+	      forceUpdate({
+	        inst: inst
+	      });
+	    }
+	  }, [subscribe, value, getSnapshot]);
+	  useEffect(function () {
+	    // Check for changes right before subscribing. Subsequent changes will be
+	    // detected in the subscription handler.
+	    if (checkIfSnapshotChanged(inst)) {
+	      // Force a re-render.
+	      forceUpdate({
+	        inst: inst
+	      });
+	    }
+
+	    var handleStoreChange = function () {
+	      // TODO: Because there is no cross-renderer API for batching updates, it's
+	      // up to the consumer of this library to wrap their subscription event
+	      // with unstable_batchedUpdates. Should we try to detect when this isn't
+	      // the case and print a warning in development?
+	      // The store changed. Check if the snapshot changed since the last time we
+	      // read from the store.
+	      if (checkIfSnapshotChanged(inst)) {
+	        // Force a re-render.
+	        forceUpdate({
+	          inst: inst
+	        });
+	      }
+	    }; // Subscribe to the store and return a clean-up function.
+
+
+	    return subscribe(handleStoreChange);
+	  }, [subscribe]);
+	  useDebugValue(value);
+	  return value;
+	}
+
+	function checkIfSnapshotChanged(inst) {
+	  var latestGetSnapshot = inst.getSnapshot;
+	  var prevValue = inst.value;
+
+	  try {
+	    var nextValue = latestGetSnapshot();
+	    return !objectIs(prevValue, nextValue);
+	  } catch (error) {
+	    return true;
+	  }
+	}
+
+	function useSyncExternalStore$1(subscribe, getSnapshot, getServerSnapshot) {
+	  // Note: The shim does not use getServerSnapshot, because pre-18 versions of
+	  // React do not expose a way to check if we're hydrating. So users of the shim
+	  // will need to track that themselves and return the correct value
+	  // from `getSnapshot`.
+	  return getSnapshot();
+	}
+
+	var canUseDOM = !!(typeof window !== 'undefined' && typeof window.document !== 'undefined' && typeof window.document.createElement !== 'undefined');
+
+	var isServerEnvironment = !canUseDOM;
+
+	var shim = isServerEnvironment ? useSyncExternalStore$1 : useSyncExternalStore;
+	var useSyncExternalStore$2 = React.useSyncExternalStore !== undefined ? React.useSyncExternalStore : shim;
+
+	useSyncExternalStoreShim_development.useSyncExternalStore = useSyncExternalStore$2;
+	          /* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */
+	if (
+	  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' &&
+	  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop ===
+	    'function'
+	) {
+	  __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(new Error());
+	}
+	        
+	  })();
+	}
+	return useSyncExternalStoreShim_development;
+}
+
+if (process.env.NODE_ENV === 'production') {
+  shim.exports = requireUseSyncExternalStoreShim_production_min();
+} else {
+  shim.exports = requireUseSyncExternalStoreShim_development();
+}
+
+var shimExports = shim.exports;
+
+const useSyncExternalStore = shimExports.useSyncExternalStore;
+
+const defaultContext = /*#__PURE__*/React__namespace.createContext(undefined);
+const QueryClientSharingContext = /*#__PURE__*/React__namespace.createContext(false); // If we are given a context, we will use it.
+// Otherwise, if contextSharing is on, we share the first and at least one
+// instance of the context across the window
+// to ensure that if React Query is used across
+// different bundles or microfrontends they will
+// all use the same **instance** of context, regardless
+// of module scoping.
+
+function getQueryClientContext(context, contextSharing) {
+  if (context) {
+    return context;
+  }
+
+  if (contextSharing && typeof window !== 'undefined') {
+    if (!window.ReactQueryClientContext) {
+      window.ReactQueryClientContext = defaultContext;
+    }
+
+    return window.ReactQueryClientContext;
+  }
+
+  return defaultContext;
+}
+
+const useQueryClient = ({
+  context
+} = {}) => {
+  const queryClient = React__namespace.useContext(getQueryClientContext(context, React__namespace.useContext(QueryClientSharingContext)));
+
+  if (!queryClient) {
+    throw new Error('No QueryClient set, use QueryClientProvider to set one');
+  }
+
+  return queryClient;
+};
+const QueryClientProvider = ({
+  client,
+  children,
+  context,
+  contextSharing = false
+}) => {
+  React__namespace.useEffect(() => {
+    client.mount();
+    return () => {
+      client.unmount();
+    };
+  }, [client]);
+
+  if (process.env.NODE_ENV !== 'production' && contextSharing) {
+    client.getLogger().error("The contextSharing option has been deprecated and will be removed in the next major version");
+  }
+
+  const Context = getQueryClientContext(context, contextSharing);
+  return /*#__PURE__*/React__namespace.createElement(QueryClientSharingContext.Provider, {
+    value: !context && contextSharing
+  }, /*#__PURE__*/React__namespace.createElement(Context.Provider, {
+    value: client
+  }, children));
+};
+
+const IsRestoringContext = /*#__PURE__*/React__namespace.createContext(false);
+const useIsRestoring = () => React__namespace.useContext(IsRestoringContext);
+IsRestoringContext.Provider;
+
+function createValue() {
+  let isReset = false;
+  return {
+    clearReset: () => {
+      isReset = false;
+    },
+    reset: () => {
+      isReset = true;
+    },
+    isReset: () => {
+      return isReset;
+    }
+  };
+}
+
+const QueryErrorResetBoundaryContext = /*#__PURE__*/React__namespace.createContext(createValue()); // HOOK
+
+const useQueryErrorResetBoundary = () => React__namespace.useContext(QueryErrorResetBoundaryContext); // COMPONENT
+
+function shouldThrowError(_useErrorBoundary, params) {
+  // Allow useErrorBoundary function to override throwing behavior on a per-error basis
+  if (typeof _useErrorBoundary === 'function') {
+    return _useErrorBoundary(...params);
+  }
+
+  return !!_useErrorBoundary;
+}
+
+const ensurePreventErrorBoundaryRetry = (options, errorResetBoundary) => {
+  if (options.suspense || options.useErrorBoundary) {
+    // Prevent retrying failed query if the error boundary has not been reset yet
+    if (!errorResetBoundary.isReset()) {
+      options.retryOnMount = false;
+    }
+  }
+};
+const useClearResetErrorBoundary = errorResetBoundary => {
+  React__namespace.useEffect(() => {
+    errorResetBoundary.clearReset();
+  }, [errorResetBoundary]);
+};
+const getHasError = ({
+  result,
+  errorResetBoundary,
+  useErrorBoundary,
+  query
+}) => {
+  return result.isError && !errorResetBoundary.isReset() && !result.isFetching && shouldThrowError(useErrorBoundary, [result.error, query]);
+};
+
+const ensureStaleTime = defaultedOptions => {
+  if (defaultedOptions.suspense) {
+    // Always set stale time when using suspense to prevent
+    // fetching again when directly mounting after suspending
+    if (typeof defaultedOptions.staleTime !== 'number') {
+      defaultedOptions.staleTime = 1000;
+    }
+  }
+};
+const willFetch = (result, isRestoring) => result.isLoading && result.isFetching && !isRestoring;
+const shouldSuspend = (defaultedOptions, result, isRestoring) => (defaultedOptions == null ? void 0 : defaultedOptions.suspense) && willFetch(result, isRestoring);
+const fetchOptimistic = (defaultedOptions, observer, errorResetBoundary) => observer.fetchOptimistic(defaultedOptions).then(({
+  data
+}) => {
+  defaultedOptions.onSuccess == null ? void 0 : defaultedOptions.onSuccess(data);
+  defaultedOptions.onSettled == null ? void 0 : defaultedOptions.onSettled(data, null);
+}).catch(error => {
+  errorResetBoundary.clearReset();
+  defaultedOptions.onError == null ? void 0 : defaultedOptions.onError(error);
+  defaultedOptions.onSettled == null ? void 0 : defaultedOptions.onSettled(undefined, error);
+});
+
+function useQueries({
+  queries,
+  context
+}) {
+  const queryClient = useQueryClient({
+    context
+  });
+  const isRestoring = useIsRestoring();
+  const errorResetBoundary = useQueryErrorResetBoundary();
+  const defaultedQueries = React__namespace.useMemo(() => queries.map(options => {
+    const defaultedOptions = queryClient.defaultQueryOptions(options); // Make sure the results are already in fetching state before subscribing or updating options
+
+    defaultedOptions._optimisticResults = isRestoring ? 'isRestoring' : 'optimistic';
+    return defaultedOptions;
+  }), [queries, queryClient, isRestoring]);
+  defaultedQueries.forEach(query => {
+    ensureStaleTime(query);
+    ensurePreventErrorBoundaryRetry(query, errorResetBoundary);
+  });
+  useClearResetErrorBoundary(errorResetBoundary);
+  const [observer] = React__namespace.useState(() => new QueriesObserver(queryClient, defaultedQueries));
+  const optimisticResult = observer.getOptimisticResult(defaultedQueries);
+  useSyncExternalStore(React__namespace.useCallback(onStoreChange => isRestoring ? () => undefined : observer.subscribe(notifyManager.batchCalls(onStoreChange)), [observer, isRestoring]), () => observer.getCurrentResult(), () => observer.getCurrentResult());
+  React__namespace.useEffect(() => {
+    // Do not notify on updates because of changes in the options because
+    // these changes should already be reflected in the optimistic result.
+    observer.setQueries(defaultedQueries, {
+      listeners: false
+    });
+  }, [defaultedQueries, observer]);
+  const shouldAtLeastOneSuspend = optimisticResult.some((result, index) => shouldSuspend(defaultedQueries[index], result, isRestoring));
+  const suspensePromises = shouldAtLeastOneSuspend ? optimisticResult.flatMap((result, index) => {
+    const options = defaultedQueries[index];
+    const queryObserver = observer.getObservers()[index];
+
+    if (options && queryObserver) {
+      if (shouldSuspend(options, result, isRestoring)) {
+        return fetchOptimistic(options, queryObserver, errorResetBoundary);
+      } else if (willFetch(result, isRestoring)) {
+        void fetchOptimistic(options, queryObserver, errorResetBoundary);
+      }
+    }
+
+    return [];
+  }) : [];
+
+  if (suspensePromises.length > 0) {
+    throw Promise.all(suspensePromises);
+  }
+
+  const observerQueries = observer.getQueries();
+  const firstSingleResultWhichShouldThrow = optimisticResult.find((result, index) => {
+    var _defaultedQueries$ind, _defaultedQueries$ind2;
+
+    return getHasError({
+      result,
+      errorResetBoundary,
+      useErrorBoundary: (_defaultedQueries$ind = (_defaultedQueries$ind2 = defaultedQueries[index]) == null ? void 0 : _defaultedQueries$ind2.useErrorBoundary) != null ? _defaultedQueries$ind : false,
+      query: observerQueries[index]
+    });
+  });
+
+  if (firstSingleResultWhichShouldThrow != null && firstSingleResultWhichShouldThrow.error) {
+    throw firstSingleResultWhichShouldThrow.error;
+  }
+
+  return optimisticResult;
+}
+
+function useBaseQuery(options, Observer) {
+  const queryClient = useQueryClient({
+    context: options.context
+  });
+  const isRestoring = useIsRestoring();
+  const errorResetBoundary = useQueryErrorResetBoundary();
+  const defaultedOptions = queryClient.defaultQueryOptions(options); // Make sure results are optimistically set in fetching state before subscribing or updating options
+
+  defaultedOptions._optimisticResults = isRestoring ? 'isRestoring' : 'optimistic'; // Include callbacks in batch renders
+
+  if (defaultedOptions.onError) {
+    defaultedOptions.onError = notifyManager.batchCalls(defaultedOptions.onError);
+  }
+
+  if (defaultedOptions.onSuccess) {
+    defaultedOptions.onSuccess = notifyManager.batchCalls(defaultedOptions.onSuccess);
+  }
+
+  if (defaultedOptions.onSettled) {
+    defaultedOptions.onSettled = notifyManager.batchCalls(defaultedOptions.onSettled);
+  }
+
+  ensureStaleTime(defaultedOptions);
+  ensurePreventErrorBoundaryRetry(defaultedOptions, errorResetBoundary);
+  useClearResetErrorBoundary(errorResetBoundary);
+  const [observer] = React__namespace.useState(() => new Observer(queryClient, defaultedOptions));
+  const result = observer.getOptimisticResult(defaultedOptions);
+  useSyncExternalStore(React__namespace.useCallback(onStoreChange => {
+    const unsubscribe = isRestoring ? () => undefined : observer.subscribe(notifyManager.batchCalls(onStoreChange)); // Update result to make sure we did not miss any query updates
+    // between creating the observer and subscribing to it.
+
+    observer.updateResult();
+    return unsubscribe;
+  }, [observer, isRestoring]), () => observer.getCurrentResult(), () => observer.getCurrentResult());
+  React__namespace.useEffect(() => {
+    // Do not notify on updates because of changes in the options because
+    // these changes should already be reflected in the optimistic result.
+    observer.setOptions(defaultedOptions, {
+      listeners: false
+    });
+  }, [defaultedOptions, observer]); // Handle suspense
+
+  if (shouldSuspend(defaultedOptions, result, isRestoring)) {
+    throw fetchOptimistic(defaultedOptions, observer, errorResetBoundary);
+  } // Handle error boundary
+
+
+  if (getHasError({
+    result,
+    errorResetBoundary,
+    useErrorBoundary: defaultedOptions.useErrorBoundary,
+    query: observer.getCurrentQuery()
+  })) {
+    throw result.error;
+  } // Handle result property usage tracking
+
+
+  return !defaultedOptions.notifyOnChangeProps ? observer.trackResult(result) : result;
+}
+
+function useQuery(arg1, arg2, arg3) {
+  const parsedOptions = parseQueryArgs(arg1, arg2, arg3);
+  return useBaseQuery(parsedOptions, QueryObserver);
+}
+
+function useMutation(arg1, arg2, arg3) {
+  const options = parseMutationArgs(arg1, arg2, arg3);
+  const queryClient = useQueryClient({
+    context: options.context
+  });
+  const [observer] = React__namespace.useState(() => new MutationObserver(queryClient, options));
+  React__namespace.useEffect(() => {
+    observer.setOptions(options);
+  }, [observer, options]);
+  const result = useSyncExternalStore(React__namespace.useCallback(onStoreChange => observer.subscribe(notifyManager.batchCalls(onStoreChange)), [observer]), () => observer.getCurrentResult(), () => observer.getCurrentResult());
+  const mutate = React__namespace.useCallback((variables, mutateOptions) => {
+    observer.mutate(variables, mutateOptions).catch(noop);
+  }, [observer]);
+
+  if (result.error && shouldThrowError(observer.options.useErrorBoundary, [result.error])) {
+    throw result.error;
+  }
+
+  return { ...result,
+    mutate,
+    mutateAsync: result.mutate
+  };
+} // eslint-disable-next-line @typescript-eslint/no-empty-function
+
+function noop() {}
+
+exports.TransactionErrorType = void 0;
+(function (TransactionErrorType) {
+    TransactionErrorType[TransactionErrorType["REJECTED_BY_USER"] = 0] = "REJECTED_BY_USER";
+    TransactionErrorType[TransactionErrorType["CALL_EXCEPTION"] = 1] = "CALL_EXCEPTION";
+    TransactionErrorType[TransactionErrorType["UNKNOWN"] = 2] = "UNKNOWN";
+    TransactionErrorType[TransactionErrorType["WARNING"] = 3] = "WARNING";
+})(exports.TransactionErrorType || (exports.TransactionErrorType = {}));
+exports.SquidStatusErrorType = void 0;
+(function (SquidStatusErrorType) {
+    SquidStatusErrorType["NotFoundError"] = "NotFoundError";
+})(exports.SquidStatusErrorType || (exports.SquidStatusErrorType = {}));
+class QrCodeGenerationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "QrCodeGenerationError";
+    }
+}
+
 /**
  * The base implementation of `_.slice` without an iteratee call guard.
  *
@@ -20117,17 +23745,14 @@ function isXrplAddressValid(address) {
     return rippleAddressCodec.isValidXAddress(address) || rippleAddressCodec.isValidClassicAddress(address);
 }
 function buildXrplTrustSetTx({ amount, sourceAddress, token, }) {
-    const asset = parseXrplTokenAddress(token.address);
-    if (!asset) {
-        throw new Error("Invalid asset");
-    }
+    const [currency, issuer] = token.address.split(".");
     return {
         TransactionType: XrplTransactionType.TRUST_SET,
         Flags: XrplTransactionFlag.tfSetNoRipple,
         Account: sourceAddress,
         LimitAmount: {
-            currency: asset.code,
-            issuer: asset.issuer,
+            currency,
+            issuer,
             value: amount,
         },
     };
@@ -20156,16 +23781,6 @@ function parseXrplPaymentTx(data) {
         throw new Error("Could not parse payment transaction");
     }
 }
-function parseXrplTokenAddress(address) {
-    const [code, issuer] = address.split(".");
-    if (!code || !issuer) {
-        return null;
-    }
-    return {
-        code,
-        issuer,
-    };
-}
 
 const chains = [XrplCAIP2ChainId.MAINNET, XrplCAIP2ChainId.TESTNET];
 class XrplWalletConnect {
@@ -21131,28 +24746,6 @@ const executeSolanaTransfer = async ({ amount, target, signer, connection, sourc
     return signature;
 };
 
-var StellarHorizonAssetType;
-(function (StellarHorizonAssetType) {
-    /**
-     * XLM native token
-     */
-    StellarHorizonAssetType["NATIVE"] = "native";
-    /**
-     * 1-4 char asset code (e.g. USDC)
-     */
-    StellarHorizonAssetType["ALPHANUM4"] = "credit_alphanum4";
-    /**
-     * 5-12 char asset code (e.g. wstETH)
-     */
-    StellarHorizonAssetType["ALPHANUM12"] = "credit_alphanum12";
-})(StellarHorizonAssetType || (StellarHorizonAssetType = {}));
-var StellarTokenType;
-(function (StellarTokenType) {
-    StellarTokenType["NATIVE_TOKEN"] = "nativeToken";
-    StellarTokenType["ISSUER_TOKEN"] = "issuerToken";
-    StellarTokenType["CONTRACT_TOKEN"] = "contractToken";
-})(StellarTokenType || (StellarTokenType = {}));
-
 function isStellarAddressValid(address) {
     return stellarSdk.StrKey.isValidEd25519PublicKey(address);
 }
@@ -21174,78 +24767,6 @@ function stellarAddressToScVal(addressString) {
         type: "address",
     });
 }
-function getStellarTrustLineAsset(token) {
-    // The address format for issued assets is `CODE-ISSUER`
-    // Example: USDC-GA5ZSEJYB37JRC5AVCIA5MOP4RHTM335X2KGX3IHOJAPP5RE34K4KZVN
-    const [code, issuer] = token.address.split("-");
-    if (!code || !issuer) {
-        return null;
-    }
-    return {
-        code,
-        issuer,
-    };
-}
-function isStellarToken(token) {
-    try {
-        const stellarToken = token;
-        return (Object.values(StellarTokenType).includes(stellarToken.chainAssetConfig.stellar.assetType) &&
-            typeof stellarToken.chainAssetConfig.stellar.contractAddress === "string");
-    }
-    catch {
-        return false;
-    }
-}
-function isStellarIssuedToken(token) {
-    try {
-        return (isStellarToken(token) &&
-            token.chainAssetConfig.stellar.assetType === StellarTokenType.ISSUER_TOKEN);
-    }
-    catch {
-        return false;
-    }
-}
-function getStellarHorizonApiUrl(chain) {
-    try {
-        const stellarChain = chain;
-        const [horizonApiUrl] = stellarChain.horizonRpcList;
-        if (typeof horizonApiUrl !== "string") {
-            throw new Error("Invalid Horizon API URL");
-        }
-        return horizonApiUrl;
-    }
-    catch {
-        return null;
-    }
-}
-const VALID_ASSET_TYPES = new Set(Object.values(StellarHorizonAssetType));
-function isValidNativeAsset(asset) {
-    return (typeof asset === "object" &&
-        asset !== null &&
-        "balance" in asset &&
-        typeof asset.balance === "string" &&
-        "asset_type" in asset &&
-        asset.asset_type === StellarHorizonAssetType.NATIVE);
-}
-function isValidIssuedAsset(asset) {
-    return (typeof asset === "object" &&
-        asset !== null &&
-        "balance" in asset &&
-        typeof asset.balance === "string" &&
-        "asset_type" in asset &&
-        typeof asset.asset_type === "string" &&
-        VALID_ASSET_TYPES.has(asset.asset_type) &&
-        asset.asset_type !== StellarHorizonAssetType.NATIVE &&
-        "asset_code" in asset &&
-        typeof asset.asset_code === "string" &&
-        "asset_issuer" in asset &&
-        typeof asset.asset_issuer === "string" &&
-        "limit" in asset &&
-        typeof asset.limit === "string");
-}
-function isValidHorizonAsset(asset) {
-    return isValidNativeAsset(asset) || isValidIssuedAsset(asset);
-}
 
 const SUI_FEATURES = ["sui:signTransaction"];
 function isSuiStandardWallet(wallet) {
@@ -22324,8 +25845,6 @@ exports.QueryKeys = void 0;
     QueryKeys["XrplAccountActivatedInfo"] = "xrplAccountActivatedInfo";
     QueryKeys["FiatToCryptoPaymentMethods"] = "fiatToCryptoPaymentMethods";
     QueryKeys["Stellar"] = "stellar";
-    QueryKeys["StellarTrustLine"] = "stellarTrustLine";
-    QueryKeys["IsStellarTrustLineApproved"] = "isStellarTrustLineApproved";
     QueryKeys["StellarAccountActivatedInfo"] = "stellarAccountActivatedInfo";
     QueryKeys["Hedera"] = "hedera";
     QueryKeys["IsHederaTokenAssociated"] = "isHederaTokenAssociated";
@@ -22433,7 +25952,7 @@ const keys = () => ({
     // ============
     // Approval
     // ============
-    routeApproved: (routeData, allowanceInWei, isAllowanceQueryEnabled, hasAllowance) => [
+    routeApproved: (routeData, allowanceInWei) => [
         ...keys().transactions(),
         exports.QueryKeys.RouteApproved,
         routeData?.params.fromAddress,
@@ -22441,8 +25960,6 @@ const keys = () => ({
         routeData?.params.fromToken,
         routeData?.params.fromAmount,
         allowanceInWei?.toString(),
-        isAllowanceQueryEnabled,
-        hasAllowance,
     ],
     sendTransactionGas: (chainId, tokenAddress, from) => [
         exports.QueryKeys.All,
@@ -22515,23 +26032,6 @@ const keys = () => ({
     // ============
     // Stellar
     // ============
-    stellarTrustLine: (tokenAddress, chainId, address) => [
-        ...keys().stellar(),
-        exports.QueryKeys.StellarTrustLine,
-        tokenAddress,
-        chainId,
-        address,
-    ],
-    isStellarTrustLineApproved: (address, chainId, chainType, tokenAddress, trustLineLimit, amountToApprove) => [
-        ...keys().stellar(),
-        exports.QueryKeys.IsStellarTrustLineApproved,
-        address,
-        chainId,
-        chainType,
-        tokenAddress,
-        trustLineLimit,
-        amountToApprove?.toString(),
-    ],
     stellarAccountActivatedInfo: (address, chainId, chainType) => [
         ...keys().stellar(),
         exports.QueryKeys.StellarAccountActivatedInfo,
@@ -22567,8 +26067,6 @@ const getPrefixKey = (key) => {
             return [...keys().transactions(), key];
         case exports.QueryKeys.XrplTrustLine:
             return [...keys().xrpl(), key];
-        case exports.QueryKeys.StellarTrustLine:
-            return [...keys().stellar(), key];
         case exports.QueryKeys.IsHederaTokenAssociated:
             return [...keys().hedera(), key];
         default:
@@ -23283,7 +26781,7 @@ const filterViewableTokens = (tokens, config, direction) => {
 };
 const getSecretNetworkBalances = async (chainData, cosmosAddress, squidTokens, keplrTypeWallet) => {
     const squidSecretTokens = squidTokens.filter((t) => t.chainId === CHAIN_IDS.SECRET);
-    const { fetchAllSecretBalances } = await Promise.resolve().then(function () { return require('./secretService-CdbkGf17.js'); });
+    const { fetchAllSecretBalances } = await Promise.resolve().then(function () { return require('./secretService-CY6elBY4.js'); });
     return fetchAllSecretBalances(chainData, cosmosAddress, squidSecretTokens, keplrTypeWallet);
 };
 function getTokenAssetsKey(token) {
@@ -25162,7 +28660,7 @@ const useSquid = () => {
      * Fetch squid info
      * Will refetch every minute
      */
-    const squidInfoQuery = reactQuery.useQuery({
+    const squidInfoQuery = useQuery({
         queryKey: keys().squidInfo(),
         queryFn: async () => {
             if (squid) {
@@ -25335,7 +28833,7 @@ const createTransactionStatusConfig = ({ transactionId, walletAddress, providerI
 const useGetFiatQuote = ({ fiatCurrency, cryptoCurrencyID, amount, region, paymentMethod, enabled = true, onSuccess, }) => {
     const service = React.useMemo(() => new OnrampService(), []);
     const { data: config } = useGetOnRampConfig();
-    return reactQuery.useQuery({
+    return useQuery({
         queryKey: keys().fiatToCryptoQuote(fiatCurrency, cryptoCurrencyID, amount, region, paymentMethod),
         queryFn: async () => {
             // Dispatch event before getting quote
@@ -25379,7 +28877,7 @@ const useGetOnRampConfig = () => {
     const service = React.useMemo(() => new OnrampService(), []);
     const { chains } = useSquidChains();
     const { tokens } = useSquidTokens();
-    return reactQuery.useQuery({
+    return useQuery({
         queryKey: keys().fiatToCryptoConfig(),
         queryFn: () => service.getConfiguration({
             chains,
@@ -25397,7 +28895,7 @@ const useExecuteFiatQuote = () => {
     const service = React.useMemo(() => new OnrampService(), []);
     const persistTransaction = useHistoryStore((state) => state.persistTransaction);
     const { findChain } = useSquidChains();
-    return reactQuery.useMutation({
+    return useMutation({
         mutationFn: async (executeQuoteRequest) => {
             const chain = findChain(executeQuoteRequest.squidToken?.chainId);
             if (!chain) {
@@ -25448,7 +28946,7 @@ const useExecuteFiatQuote = () => {
  */
 const useFiatOnRampTxStatus = (transactionId, walletAddress, providerId) => {
     const replaceTransactionStatus = useHistoryStore((state) => state.replaceTransactionStatus);
-    return reactQuery.useQuery({
+    return useQuery({
         ...createTransactionStatusConfig({
             transactionId,
             walletAddress,
@@ -25464,7 +28962,7 @@ const useFiatTransactions = () => {
     const transactions = useHistoryStore((state) => state.transactions.filter((tx) => tx.txType === exports.HistoryTxType.BUY));
     const replaceTransactionStatus = useHistoryStore((state) => state.replaceTransactionStatus);
     const pendingTransactions = React.useMemo(() => transactions?.filter((tx) => !FINAL_TRANSACTION_STATUSES.includes(tx.data.status)) ?? [], [transactions]);
-    const queries = reactQuery.useQueries({
+    const queries = useQueries({
         queries: pendingTransactions.map((tx) => ({
             ...createTransactionStatusConfig({
                 transactionId: tx.data.orderId,
@@ -25548,7 +29046,7 @@ const useRecommendedQuote = (quotes, recommendedQuote) => {
  */
 const useGetOnrampPaymentTypes = ({ fiatCurrency, cryptoCurrencyID, region, enabled = true, }) => {
     const service = React.useMemo(() => new OnrampService(), []);
-    return reactQuery.useQuery({
+    return useQuery({
         queryKey: keys().fiatToCryptoPaymentMethods(fiatCurrency, cryptoCurrencyID, region),
         queryFn: () => service.getPaymentTypes(fiatCurrency, cryptoCurrencyID, region),
         enabled: enabled && !!fiatCurrency && !!cryptoCurrencyID,
@@ -26084,7 +29582,7 @@ const EU_COUNTRIES = [
 const useClient = () => {
     const isClient = typeof window !== "undefined";
     const clientWindow = isClient ? window : undefined;
-    const { data: countryData } = reactQuery.useQuery({
+    const { data: countryData } = useQuery({
         queryKey: keys().country(),
         queryFn: getUserCountry,
         enabled: isClient,
@@ -26190,7 +29688,7 @@ function useDebouncedValue(value, delay) {
  * @returns the ENS data of the given address
  */
 function useEnsDataForAddress({ address, options, }) {
-    const ensQuery = reactQuery.useQuery(keys().ensData(address?.toLowerCase()), () => EnsService.getEnsDataFromAddress(address), {
+    const ensQuery = useQuery(keys().ensData(address?.toLowerCase()), () => EnsService.getEnsDataFromAddress(address), {
         ...options,
         enabled: Boolean(address?.trim()) &&
             (options?.enabled === undefined ? true : options.enabled),
@@ -26210,7 +29708,7 @@ function useEnsDataForAddress({ address, options, }) {
  */
 function useEnsSearch({ name, enabled = true, delayMs = 500, }) {
     const debouncedName = useDebouncedValue(enabled ? name : undefined, delayMs);
-    const ensSearchQuery = reactQuery.useQuery(keys().ensSearch(debouncedName), () => {
+    const ensSearchQuery = useQuery(keys().ensSearch(debouncedName), () => {
         const isExactEnsSearch = checkIsExactEns(debouncedName);
         return isExactEnsSearch
             ? EnsService.getExactEns(debouncedName)
@@ -26238,7 +29736,7 @@ function checkIsExactEns(name = "") {
 
 const useCosmosForChain = (chain) => {
     const { keplrTypeWallet } = useCosmosSigner({ chain });
-    const cosmosAddressQuery = reactQuery.useQuery(keys().cosmosAddress(chain?.chainId), async () => {
+    const cosmosAddressQuery = useQuery(keys().cosmosAddress(chain?.chainId), async () => {
         if (!chain || !keplrTypeWallet)
             return "";
         try {
@@ -26331,7 +29829,7 @@ const useIsSameAddressAndGnosisContext = () => {
 
 function useBitcoin() {
     const connectedBitcoinWallet = useWalletStore((store) => store.connectedWalletsByChainType[squidTypes.ChainType.BTC]);
-    const connectBitcoin = reactQuery.useMutation(async ({ wallet, }) => {
+    const connectBitcoin = useMutation(async ({ wallet, }) => {
         const { address } = await wallet.connector.requestAccount();
         return {
             wallet,
@@ -26376,7 +29874,7 @@ function useEvm() {
     const { wallets } = useEvmWallets();
     const connectedEvmWallet = useWalletStore((store) => store.connectedWalletsByChainType[squidTypes.ChainType.EVM]);
     const recentEvmWalletId = useWalletStore((store) => store.recentConnectorIds[squidTypes.ChainType.EVM]);
-    const connectEvm = reactQuery.useMutation(async ({ wallet, }) => {
+    const connectEvm = useMutation(async ({ wallet, }) => {
         const result = await connectAsync({
             connector: wallet.connector,
         });
@@ -26478,7 +29976,7 @@ function useSolana() {
     const { wallets } = useSolanaWallets();
     const connectedSolanaWallet = useWalletStore((store) => store.connectedWalletsByChainType[squidTypes.ChainType.SOLANA]);
     const recentSolanaWalletId = useWalletStore((store) => store.recentConnectorIds[squidTypes.ChainType.SOLANA]);
-    const connectSolana = reactQuery.useMutation(async ({ wallet, }) => {
+    const connectSolana = useMutation(async ({ wallet, }) => {
         try {
             // try to connect silently first
             await wallet.connector.autoConnect();
@@ -26568,7 +30066,7 @@ function useStellarWallets() {
             try {
                 const { allowAllModules: initializeAllModules } = await import('@creit.tech/stellar-wallets-kit');
                 const { LedgerModule } = await import('@creit.tech/stellar-wallets-kit/modules/ledger.module');
-                const { formatStellarWallet } = await Promise.resolve().then(function () { return require('./stellarService.client-ESo7_qhK.js'); });
+                const { formatStellarWallet } = await Promise.resolve().then(function () { return require('./stellarService.client-2CVAOoJl.js'); });
                 const modules = [...initializeAllModules(), new LedgerModule()];
                 const promises = modules.map(async (module) => {
                     const isAvailable = await module.isAvailable();
@@ -26596,7 +30094,7 @@ function useStellarWallets() {
 function useStellar() {
     const { wallets } = useStellarWallets();
     const connectedStellarWallet = useWalletStore((store) => store.connectedWalletsByChainType[squidTypes.ChainType.STELLAR]);
-    const connectStellar = reactQuery.useMutation(async ({ wallet, }) => {
+    const connectStellar = useMutation(async ({ wallet, }) => {
         const { address } = await wallet.connector.getAddress();
         return {
             wallet,
@@ -26653,7 +30151,7 @@ function useSui() {
     const recentSuiWalletId = useWalletStore((store) => store.recentConnectorIds[squidTypes.ChainType.SUI]);
     const setConnectedWallet = useWalletStore((store) => store.setConnectedWallet);
     const disconnectWallet = useWalletStore((store) => store.disconnectWallet);
-    const connectSui = reactQuery.useMutation(async ({ wallet, }) => {
+    const connectSui = useMutation(async ({ wallet, }) => {
         let account;
         try {
             // try to connect silently first
@@ -26977,7 +30475,7 @@ function useXrpl() {
     const recentXrplWalletId = useWalletStore((store) => store.recentConnectorIds[squidTypes.ChainType.XRPL]);
     const setConnectedWallet = useWalletStore((store) => store.setConnectedWallet);
     const disconnectWallet = useWalletStore((store) => store.disconnectWallet);
-    const connectXrpl = reactQuery.useMutation(async ({ wallet, }) => {
+    const connectXrpl = useMutation(async ({ wallet, }) => {
         const xrplConnectedAddress = await wallet.connector.connect();
         return {
             wallet,
@@ -27091,7 +30589,7 @@ const useWallet = () => {
             wallet,
         });
     };
-    const connectWalletMutation = reactQuery.useMutation({
+    const connectWalletMutation = useMutation({
         mutationFn: async ({ wallet, chain, selectedChainTypes, }) => {
             if (!wallet.skipInstallCheck && !wallet.isInstalled?.()) {
                 redirectToExtensionsStore(wallet);
@@ -27369,7 +30867,7 @@ const useMultiChainWallet = (chain) => {
     /**
      * Change current network for desired chain
      */
-    const changeNetworkIfNeeded = reactQuery.useMutation(async () => {
+    const changeNetworkIfNeeded = useMutation(async () => {
         const isNotOnDesiredChain = chain?.chainType === squidTypes.ChainType.EVM &&
             currentEvmChain?.id !== Number(chain.chainId);
         if (isNotOnDesiredChain) {
@@ -27470,7 +30968,7 @@ const useSwap = () => {
     const fromPrice = useTransactionStore((state) => state.fromPrice);
     const { swapRoute } = useSwapRoutePersistStore();
     const { tokens } = useSquidTokens();
-    const queryClient = reactQuery.useQueryClient();
+    const queryClient = useQueryClient();
     const { chains, supportedDestinationChains, supportedSourceChains } = useSquidChains();
     const sourceChainId = React.useMemo(() => swapRoute?.fromChainId ||
         (supportedSourceChains.find((c) => c.chainId === initialAssets?.from?.chainId) &&
@@ -27740,7 +31238,7 @@ const useCosmos = () => {
             clientWindow?.removeEventListener("keplr_keystorechange", () => handleKeplrAccountChanged());
         };
     }, [handleKeplrAccountChanged, clientWindow]);
-    const connectCosmos = reactQuery.useMutation(async ({ chain, wallet, approveAllChains = true, }) => {
+    const connectCosmos = useMutation(async ({ chain, wallet, approveAllChains = true, }) => {
         const chainInfos = getCosmosChainInfosObject(chain);
         const cosmosWalletObject = wallet.connector().provider;
         if (cosmosWalletObject) {
@@ -28068,7 +31566,7 @@ function hederaWalletConnect(parameters) {
                 const optionalChains = config.chains.map((x) => x.id);
                 if (!optionalChains.length)
                     return;
-                const { EthereumProvider } = await Promise.resolve().then(function () { return require('./index.es-CT2n71aB.js'); });
+                const { EthereumProvider } = await Promise.resolve().then(function () { return require('./index.es-C5DLFXAX.js'); });
                 const rawProvider = await EthereumProvider.init({
                     ...restParameters,
                     disableProviderPing: true,
@@ -28325,11 +31823,11 @@ function useHederaTokenAssociations({ address, chain, token }) {
         chainId: Number(CHAIN_IDS.HEDERA),
     });
     const { evmSigner } = useSigner({ chain });
-    const queryClient = reactQuery.useQueryClient();
+    const queryClient = useQueryClient();
     /**
      * Creates a token association transaction where the destination account authorizes to receive the given token
      */
-    const associateToken = reactQuery.useMutation({
+    const associateToken = useMutation({
         mutationFn: async () => {
             try {
                 if (!evmSigner) {
@@ -28381,7 +31879,7 @@ function useHederaTokenAssociations({ address, chain, token }) {
      *
      * Accounts which have max. associations set to -1 can receive any token without previous association
      */
-    const isTokenAssociated = reactQuery.useQuery({
+    const isTokenAssociated = useQuery({
         queryKey: keys().isHederaTokenAssociated(address, token?.chainId, token?.type, token?.address),
         queryFn: async () => {
             if (token?.chainId !== CHAIN_IDS.HEDERA) {
@@ -28429,7 +31927,7 @@ const useKeyboardNavigation = ({ onEscape }) => {
 };
 
 const useSquidQueryClient = () => {
-    const queryClient = reactQuery.useQueryClient();
+    const queryClient = useQueryClient();
     const invalidateQueries = (key) => {
         const prefixKey = getPrefixKey(key);
         queryClient.invalidateQueries(prefixKey);
@@ -29431,15 +32929,12 @@ const getAllXrplTokensBalance = async (userAddress, xrplTokens, xrplChains) => {
 };
 const getStellarTokenBalance = async (userAddress, token, chain) => {
     const stellarClient = await getClient(chain);
-    if (!isStellarToken(token)) {
-        throw new Error("Token must be a Stellar token");
-    }
-    const balance = await stellarClient.getBalance(userAddress, token.chainAssetConfig.stellar.contractAddress, chain.chainId);
+    const balance = await stellarClient.getBalance(userAddress, token.address, chain.chainId);
     return BigInt(balance);
 };
 const getAllStellarTokensBalance = async (userAddress, stellarTokens, stellarChains) => {
     const getBalancesForChain = async (chain) => {
-        const tokensForChain = stellarTokens.filter((t) => t.chainId === chain.chainId && isStellarToken(t));
+        const tokensForChain = stellarTokens.filter((t) => t.chainId === chain.chainId);
         const stellarClient = await getClient(chain);
         const allBalances = await stellarClient.getAllBalances(userAddress, tokensForChain);
         return allBalances.map((token) => {
@@ -29494,7 +32989,7 @@ class StellarRpcClient {
             .build();
         const simulateTxResponse = await this.server.simulateTransaction(tx);
         if ("error" in simulateTxResponse) {
-            const isNoBalanceError = /trying to get non-existing value for contract instance|trustline entry is missing for account/.test(simulateTxResponse.error);
+            const isNoBalanceError = simulateTxResponse.error.includes("trying to get non-existing value for contract instance");
             // If the error message indicates that the user has no balance just return 0
             // We don't want to spam with this error as it's pretty common
             if (isNoBalanceError) {
@@ -29510,7 +33005,7 @@ class StellarRpcClient {
     }
     async getAllBalances(userAddress, tokens) {
         const balancePromises = tokens.map((token) => {
-            return this.getBalance(userAddress, token.chainAssetConfig.stellar.contractAddress, token.chainId);
+            return this.getBalance(userAddress, token.address, token.chainId);
         });
         const results = await Promise.allSettled(balancePromises);
         const balances = results.map((result) => {
@@ -29610,9 +33105,9 @@ class XrplRpcClient {
             },
         ]);
     }
-    async getTrustLine(address, asset) {
-        const response = await this.getTrustLines(address, asset.issuer);
-        const trustLine = response.lines.find((line) => line.currency === asset.code);
+    async getTrustLine(address, issuer, currency) {
+        const response = await this.getTrustLines(address, issuer);
+        const trustLine = response.lines.find((line) => line.currency === currency);
         return trustLine ?? null;
     }
     async accountActivatedInfo(address) {
@@ -29788,32 +33283,15 @@ class StellarApiClient {
         const baseReserveBn = BigInt(latestLedger.base_reserve_in_stroops);
         return baseReserveBn;
     }
-    async getTrustLines(userAddress) {
-        const response = await fetch(`${this.apiUrl}/accounts/${userAddress}`);
-        if (!response.ok) {
-            throw new Error(`Failed to fetch account data: ${response.statusText}`);
-        }
-        const data = await response.json();
-        if (!Array.isArray(data?.balances)) {
-            throw new Error("Invalid response from Horizon API");
-        }
-        const assets = data.balances.filter(isValidHorizonAsset);
-        return assets.filter(isValidIssuedAsset);
-    }
-    async getTrustLine(address, asset) {
-        const trustLines = await this.getTrustLines(address);
-        const trustLine = trustLines.find((line) => line.asset_code === asset.code && line.asset_issuer === asset.issuer);
-        return trustLine ?? null;
-    }
 }
 
-const DEFAULT_REFETCH_INTERVAL$2 = 20_000;
+const DEFAULT_REFETCH_INTERVAL$1 = 20_000;
 function useStellarAccountActivation({ address, chain, token, }) {
     /**
      * Checks if the destination account exists on the Stellar network
      * Stellar accounts need to have a minimum balance before they can receive payments
      */
-    const accountActivatedInfo = reactQuery.useQuery({
+    const accountActivatedInfo = useQuery({
         queryKey: keys().stellarAccountActivatedInfo(address, chain?.chainId, chain?.chainType),
         queryFn: async () => {
             if (chain?.chainType !== squidTypes.ChainType.STELLAR ||
@@ -29823,8 +33301,9 @@ function useStellarAccountActivation({ address, chain, token, }) {
             if (!address) {
                 throw new Error("Destination address is required");
             }
-            const horizonApiUrl = getStellarHorizonApiUrl(chain);
-            if (!horizonApiUrl) {
+            // TODO: update types
+            const [horizonApiUrl] = chain?.horizonRpcList;
+            if (typeof horizonApiUrl !== "string") {
                 throw new Error("Invalid Horizon API URL");
             }
             const stellarApiClient = new StellarApiClient(horizonApiUrl);
@@ -29840,7 +33319,7 @@ function useStellarAccountActivation({ address, chain, token, }) {
             };
         },
         enabled: !!address && chain?.chainType === squidTypes.ChainType.STELLAR,
-        refetchInterval: DEFAULT_REFETCH_INTERVAL$2,
+        refetchInterval: DEFAULT_REFETCH_INTERVAL$1,
         refetchOnWindowFocus: true,
     });
     return {
@@ -29848,149 +33327,6 @@ function useStellarAccountActivation({ address, chain, token, }) {
     };
 }
 
-/**
- * Maximum asset amount on Stellar
- * @see https://developers.stellar.org/docs/learn/fundamentals/stellar-data-structures/assets#amount-precision
- */
-const MAX_ASSET_AMOUNT = "922337203685.4775807";
-const DEFAULT_REFETCH_INTERVAL$1 = 20_000;
-function useStellarTrustLine({ address, chain, token, amount }) {
-    const { stellarSigner } = useSigner({ chain });
-    const queryClient = reactQuery.useQueryClient();
-    /**
-     * Retrieves the destination account's trust line data for the given token
-     */
-    const trustLineQuery = reactQuery.useQuery({
-        queryKey: keys().stellarTrustLine(token?.address, chain?.chainId, address),
-        queryFn: async () => {
-            if (chain?.chainType !== squidTypes.ChainType.STELLAR ||
-                token?.type !== squidTypes.ChainType.STELLAR) {
-                return null;
-            }
-            if (!address || !isStellarAddressValid(address)) {
-                return null;
-            }
-            // Only issued tokens require trust lines
-            // Other token types like contract tokens don't need trust lines
-            if (!isStellarIssuedToken(token)) {
-                return null;
-            }
-            const asset = getStellarTrustLineAsset(token);
-            if (!asset) {
-                throw new Error("Invalid asset");
-            }
-            const horizonApiUrl = getStellarHorizonApiUrl(chain);
-            if (!horizonApiUrl) {
-                throw new Error("Invalid Horizon API URL");
-            }
-            const stellarApiClient = new StellarApiClient(horizonApiUrl);
-            return stellarApiClient.getTrustLine(address, asset);
-        },
-        enabled: !!address &&
-            chain?.chainType === squidTypes.ChainType.STELLAR &&
-            token?.type === squidTypes.ChainType.STELLAR,
-        refetchInterval: DEFAULT_REFETCH_INTERVAL$1,
-    });
-    /**
-     * Creates a trust line where the destination account authorizes to receive the given token
-     */
-    const createTrustLine = reactQuery.useMutation({
-        mutationFn: async () => {
-            try {
-                if (!stellarSigner) {
-                    throw new Error("Stellar signer not found");
-                }
-                if (!address) {
-                    throw new Error("Destination address is required");
-                }
-                if (chain?.chainType !== squidTypes.ChainType.STELLAR ||
-                    token?.type !== squidTypes.ChainType.STELLAR) {
-                    throw new Error("Chain and token to approve must be a Stellar token");
-                }
-                if (!isStellarIssuedToken(token)) {
-                    throw new Error("Token must be a Stellar issued token");
-                }
-                const assetInfo = getStellarTrustLineAsset(token);
-                if (!assetInfo) {
-                    throw new Error("Invalid asset");
-                }
-                const network = getStellarNetwork(chain.chainId);
-                if (network == null) {
-                    throw new Error(`Stellar network not found for chain ${chain.chainId}`);
-                }
-                const client = await getClient(chain);
-                const account = await client.getAccount(address);
-                const asset = new stellarSdk.Asset(assetInfo.code, assetInfo.issuer);
-                const changeTrustOperation = stellarSdk.Operation.changeTrust({
-                    asset,
-                    limit: MAX_ASSET_AMOUNT,
-                });
-                const builtTransaction = new stellarSdk.TransactionBuilder(account, {
-                    fee: (BigInt(stellarSdk.BASE_FEE) * BigInt(2)).toString(),
-                    networkPassphrase: network,
-                })
-                    .addOperation(changeTrustOperation)
-                    .setTimeout(300)
-                    .build();
-                const { signedTxXdr } = await stellarSigner.signTransaction(builtTransaction.toXDR(), {
-                    networkPassphrase: network,
-                });
-                const signedTransaction = new stellarSdk.Transaction(signedTxXdr, network);
-                const sentTransaction = await client.sendTransaction(signedTransaction);
-                const txStatus = await client.waitForTransaction(sentTransaction.hash, {
-                    interval: 1_000,
-                });
-                if (txStatus !== stellarSdk.rpc.Api.GetTransactionStatus.SUCCESS) {
-                    throw new Error(`Transaction failed with status: ${txStatus}`);
-                }
-                return true;
-            }
-            catch (error) {
-                console.error("Error creating trust line:", error);
-                return false;
-            }
-        },
-        async onSuccess() {
-            queryClient.invalidateQueries({
-                queryKey: getPrefixKey(exports.QueryKeys.StellarTrustLine),
-            });
-        },
-    });
-    /**
-     * Checks if the destination account has created a trust line to receive the given token.
-     */
-    const isTrustLineApproved = reactQuery.useQuery({
-        queryKey: keys().isStellarTrustLineApproved(address, token?.chainId, token?.type, token?.address, trustLineQuery.data?.limit, amount),
-        queryFn: async () => {
-            if (token?.type !== squidTypes.ChainType.STELLAR) {
-                return true;
-            }
-            // The native Stellar token doesn't need a trust line
-            if (token.address.toLowerCase() === nativeStellarTokenAddress.toLowerCase()) {
-                return true;
-            }
-            if (!amount) {
-                throw new Error("Amount is required");
-            }
-            const limitBn = BigNumber(trustLineQuery.data?.limit || "0");
-            const balanceBn = BigNumber(trustLineQuery.data?.balance || "0");
-            const availableAllowanceBn = limitBn.minus(balanceBn);
-            const amountBn = BigNumber(formatBNToReadable(amount, token.decimals));
-            return availableAllowanceBn.gte(amountBn);
-        },
-        enabled: !!address &&
-            !!amount &&
-            !trustLineQuery?.isLoading &&
-            trustLineQuery?.isFetched &&
-            token?.type === squidTypes.ChainType.STELLAR,
-    });
-    return {
-        createTrustLine,
-        trustLineQuery,
-        isTrustLineApproved,
-    };
-}
-
 const useAddressBookStore = zustand.create(middleware.persist((set) => ({
     addressBook: [],
     add: (newAddressData) => {
@@ -30106,7 +33442,7 @@ function useDepositAddress(squidRoute) {
         toggleDepositFlow(false);
         setDeposit(null);
     }, [toggleDepositFlow, setDeposit]);
-    const getRouteWithDeposit = reactQuery.useMutation(async ({ route }) => {
+    const getRouteWithDeposit = useMutation(async ({ route }) => {
         if (!squid)
             throw new Error("Squid SDK not initialized");
         const depositAddressResponse = (await squid.executeRoute({
@@ -30200,7 +33536,7 @@ const useAllTokensWithBalanceForChainType = ({ chainType, address, direction, qu
         xrplTokens.length,
         stellarTokens.length,
     ]);
-    const query = reactQuery.useQuery(keys().allTokensBalance(address, chainType, direction), async () => {
+    const query = useQuery(keys().allTokensBalance(address, chainType, direction), async () => {
         // Return zero balances if no address
         if (!address) {
             const defaultTokens = placeholderData.tokens;
@@ -30433,7 +33769,7 @@ const useCosmosNativeBalance = ({ address, chain, }) => {
 };
 const useBitcoinNativeBalance = ({ chain, address, }) => {
     const { nativeToken } = useNativeTokenForChain(chain);
-    const { data: rawBalance = "0", isLoading } = reactQuery.useQuery(keys().balance(chain?.chainId, nativeToken?.address, address), async () => {
+    const { data: rawBalance = "0", isLoading } = useQuery(keys().balance(chain?.chainId, nativeToken?.address, address), async () => {
         if (!address || !nativeToken)
             return "0";
         const balance = await getBitcoinNativeBalance(address);
@@ -30462,7 +33798,7 @@ const useBitcoinNativeBalance = ({ chain, address, }) => {
 };
 const useSolanaNativeBalance = ({ chain, address, }) => {
     const { nativeToken } = useNativeTokenForChain(chain);
-    const { data: rawBalance, isLoading } = reactQuery.useQuery(keys().balance(chain?.chainId, nativeToken?.address, address), async () => {
+    const { data: rawBalance, isLoading } = useQuery(keys().balance(chain?.chainId, nativeToken?.address, address), async () => {
         const balance = await getSolanaNativeBalance(address);
         return formatBNToReadable(balance, nativeToken.decimals);
     }, {
@@ -30706,7 +34042,7 @@ const useEvmBalance = ({ chain, token, userAddress, enabled = true, refreshInter
 };
 const useCosmosBalance = ({ chain, token, userAddress, enabled = true, refreshIntervalMs = DEFAULT_REFRESH_INTERVAL_MS, }) => {
     const { isConnected } = useCosmosContext();
-    const { data: balance = "0", isLoading } = reactQuery.useQuery({
+    const { data: balance = "0", isLoading } = useQuery({
         queryKey: keys().balance(chain?.chainId, token?.address, userAddress),
         queryFn: async () => {
             if (!userAddress || !token || chain?.chainType !== squidTypes.ChainType.COSMOS) {
@@ -30729,7 +34065,7 @@ const useCosmosBalance = ({ chain, token, userAddress, enabled = true, refreshIn
     return { balance, isLoading };
 };
 const useSolanaBalance = ({ chain, token, userAddress, enabled = true, refreshIntervalMs = DEFAULT_REFRESH_INTERVAL_MS, }) => {
-    const { data: balance = "0", isLoading } = reactQuery.useQuery({
+    const { data: balance = "0", isLoading } = useQuery({
         queryKey: keys().balance(chain?.chainId, token?.address, userAddress),
         queryFn: async () => {
             if (!userAddress || !token)
@@ -30760,7 +34096,7 @@ const useBitcoinBalance = ({ userAddress, chain, }) => {
     return { balance, isLoading };
 };
 const useSuiBalance = ({ chain, token, userAddress, enabled = true, refreshIntervalMs = DEFAULT_REFRESH_INTERVAL_MS, }) => {
-    const { data: balance = "0", isLoading } = reactQuery.useQuery({
+    const { data: balance = "0", isLoading } = useQuery({
         queryKey: keys().balance(chain?.chainId, token?.address, userAddress),
         queryFn: async () => {
             if (!userAddress ||
@@ -30783,7 +34119,7 @@ const useSuiBalance = ({ chain, token, userAddress, enabled = true, refreshInter
     return { balance, isLoading };
 };
 const useXrplBalance = ({ userAddress, chain, enabled, token, refreshIntervalMs = DEFAULT_REFRESH_INTERVAL_MS, }) => {
-    const { data: balance = "0", isLoading } = reactQuery.useQuery({
+    const { data: balance = "0", isLoading } = useQuery({
         queryKey: keys().balance(chain?.chainId, token?.address, userAddress),
         queryFn: async () => {
             if (!userAddress || !token || !chain)
@@ -30803,7 +34139,7 @@ const useXrplBalance = ({ userAddress, chain, enabled, token, refreshIntervalMs
     return { balance, isLoading };
 };
 const useStellarBalance = ({ userAddress, chain, enabled, token, refreshIntervalMs = DEFAULT_REFRESH_INTERVAL_MS, }) => {
-    const { data: balance = "0", isLoading } = reactQuery.useQuery({
+    const { data: balance = "0", isLoading } = useQuery({
         queryKey: keys().balance(chain?.chainId, token?.address, userAddress),
         queryFn: async () => {
             if (!userAddress || !token || !chain)
@@ -30907,7 +34243,7 @@ const useMultiChainBalance = ({ chain, token, userAddress, enabled = true, }) =>
 
 const useMultipleTokenPrices = (tokens) => {
     const coingeckoIds = Array.from(new Set(tokens.map((token) => token.coingeckoId).filter(Boolean)));
-    const coinGeckoQuery = reactQuery.useQuery({
+    const coinGeckoQuery = useQuery({
         queryKey: keys().coinGeckoPrices(coingeckoIds),
         queryFn: async () => {
             if (coingeckoIds.length === 0)
@@ -30954,7 +34290,7 @@ const useMultipleTokenPrices = (tokens) => {
  * @returns
  */
 const useSingleTokenPrice = (tokenData) => {
-    const queryClient = reactQuery.useQueryClient();
+    const queryClient = useQueryClient();
     const [tokenPrice, setTokenPrice] = React.useState(tokenData?.usdPrice);
     React.useEffect(() => {
         const updatePrice = (data) => {
@@ -31090,13 +34426,13 @@ const fetchTokensData = async (tokens) => {
 
 // Coingecko has a limit for some queries for multiple tokens, not sure what it is, but let's use 100 for now
 const useHistoricalData = (coingeckoId, timeFrame) => {
-    return reactQuery.useQuery(keys().historicalData(coingeckoId, timeFrame), () => fetchHistoricalData(coingeckoId, timeFrame), {
+    return useQuery(keys().historicalData(coingeckoId, timeFrame), () => fetchHistoricalData(coingeckoId, timeFrame), {
         staleTime: 5 * 60 * 1000,
         enabled: !!coingeckoId,
     });
 };
 const useTokensData = (tokens) => {
-    return reactQuery.useQuery(keys().tokensData(tokens), () => fetchTokensData(tokens), {
+    return useQuery(keys().tokensData(tokens), () => fetchTokensData(tokens), {
         staleTime: 60 * 1000,
         enabled: !!tokens && tokens.length > 0,
     });
@@ -31324,7 +34660,7 @@ const getProposedGasDestinationAmount = (destChainNativeToken) => {
 };
 
 function useSendTransactionGas({ chain, token, from, }) {
-    return reactQuery.useQuery({
+    return useQuery({
         queryKey: keys().sendTransactionGas(chain?.chainId, token?.address, from),
         queryFn: async () => {
             if (!chain || !token)
@@ -31613,18 +34949,15 @@ async function sendTransactionXrpl({ amount, signer, to, token, from, }) {
             txHash: hash,
         };
     }
-    const asset = parseXrplTokenAddress(token.address);
-    if (!asset) {
-        throw new Error("Invalid asset");
-    }
+    const [currency, issuer] = token.address.split(".");
     const amountFormatted = formatBNToReadable(amount, token.decimals);
     const { hash } = await signer.signAndSubmit({
         network: xrplNetwork,
         tx: {
             ...baseTransaction,
             Amount: {
-                currency: asset.code,
-                issuer: asset.issuer,
+                currency,
+                issuer,
                 value: amountFormatted,
             },
         },
@@ -31702,7 +35035,7 @@ function useSendTransaction({ to, amount, token, chain, }) {
         chain,
     });
     const solanaClient = useSolanaConnection();
-    const queryClient = reactQuery.useQueryClient();
+    const queryClient = useQueryClient();
     const { nativeToken } = useNativeTokenForChain(chain);
     const getTransaction = useSendTransactionStore((state) => state.getTransaction);
     const setTransactionState = useSendTransactionStore((state) => state.setTransactionState);
@@ -31755,7 +35088,7 @@ function useSendTransaction({ to, amount, token, chain, }) {
         connectedAddress.address,
         to,
     ]);
-    const sendTransactionMutation = reactQuery.useMutation({
+    const sendTransactionMutation = useMutation({
         mutationFn: async () => {
             const allParamsDefined = token && to && amount && chain;
             if (!allParamsDefined)
@@ -32273,7 +35606,7 @@ const useAllTransactionsStatus = ({ enabled }) => {
                 };
         }
     });
-    const queries = reactQuery.useQueries({
+    const queries = useQueries({
         queries: enabled && config.apiUrl ? statusQueries : [],
     });
     return {
@@ -32325,7 +35658,7 @@ const useErc20Allowance = ({ tokenAddress, ownerAddress, spenderAddress, amount
 const useApproval = ({ squidRoute, }) => {
     const { data: walletClient } = wagmi.useWalletClient();
     const publicClient = wagmi.usePublicClient();
-    const queryClient = reactQuery.useQueryClient();
+    const queryClient = useQueryClient();
     const squid = useSquidStore((state) => state.squid);
     const { fromChain, fromToken, fromPrice, isSameChain } = useSwap();
     const { evmSigner } = useSigner({ chain: fromChain });
@@ -32357,7 +35690,7 @@ const useApproval = ({ squidRoute, }) => {
      * On Error: Showing the error message if any
      * @returns {boolean} approved
      */
-    const routeApproved = reactQuery.useQuery(keys().routeApproved(squidRoute, allowanceInWei, erc20AllowanceQueryEnabled, hasAllowance), async () => {
+    const routeApproved = useQuery(keys().routeApproved(squidRoute, allowanceInWei), async () => {
         if (erc20AllowanceQueryEnabled) {
             return hasAllowance;
         }
@@ -32455,7 +35788,7 @@ const useApproval = ({ squidRoute, }) => {
     /**
      * Manually approve route if necessary
      */
-    const approveRoute = reactQuery.useMutation(async () => {
+    const approveRoute = useMutation(async () => {
         try {
             if (fromToken?.address.toLowerCase() ===
                 nativeEvmTokenAddress.toLowerCase()) {
@@ -35556,7 +38889,7 @@ const useExecuteTransaction = (squidRoute) => {
     const { findToken } = useSquidTokens();
     const solanaConnection = useSolanaConnection();
     const { findChain } = useSquidChains();
-    const queryClient = reactQuery.useQueryClient();
+    const queryClient = useQueryClient();
     const { connectedWalletsByChainType } = useWallet();
     const squid = useSquidStore((state) => state.squid);
     const getTransaction = useTransactionStore((state) => state.getTransaction);
@@ -35636,7 +38969,7 @@ const useExecuteTransaction = (squidRoute) => {
             txHash,
         }, findToken);
     }, [findToken]);
-    const swapMutationCosmos = reactQuery.useMutation(async ({ id, route }) => {
+    const swapMutationCosmos = useMutation(async ({ id, route }) => {
         const fromChainId = route?.params.fromChain;
         if (cosmosSigner && fromChainId) {
             try {
@@ -35744,7 +39077,7 @@ const useExecuteTransaction = (squidRoute) => {
             throw error;
         }
     }, [replaceSwapTransactionNonce, setTransactionState, sourceUserAddress]);
-    const swapMutationEvm = reactQuery.useMutation(async ({ id, route }) => {
+    const swapMutationEvm = useMutation(async ({ id, route }) => {
         await changeNetworkIfNeeded.mutateAsync();
         if (!route || !squid || !evmSigner) {
             throw new Error("Need all parameters");
@@ -35801,7 +39134,7 @@ const useExecuteTransaction = (squidRoute) => {
             });
         }
     });
-    const swapMutationSolana = reactQuery.useMutation(async ({ id, route }) => {
+    const swapMutationSolana = useMutation(async ({ id, route }) => {
         try {
             if (!route) {
                 throw new Error("Route is required");
@@ -35920,7 +39253,7 @@ const useExecuteTransaction = (squidRoute) => {
             });
         },
     });
-    const swapMutationBitcoin = reactQuery.useMutation(async ({ id, route }) => {
+    const swapMutationBitcoin = useMutation(async ({ id, route }) => {
         const { depositAddress, amount: sendAmount, chainflipStatusTrackingId, } = useDepositAddressStore.getState().deposit ?? {};
         if (!depositAddress) {
             throw new Error(`Invalid deposit address: ${depositAddress}`);
@@ -35964,7 +39297,7 @@ const useExecuteTransaction = (squidRoute) => {
             throw new Error("Need all parameters");
         }
     });
-    const swapMutationXrpl = reactQuery.useMutation(async ({ id, route }) => {
+    const swapMutationXrpl = useMutation(async ({ id, route }) => {
         if (!route?.transactionRequest || !xrplSigner) {
             throw new Error("Need all parameters");
         }
@@ -36003,7 +39336,7 @@ const useExecuteTransaction = (squidRoute) => {
             throw new Error(`Transaction failed with status: ${txRes.status}`);
         }
     }, {});
-    const swapMutationSui = reactQuery.useMutation(async ({ id, route }) => {
+    const swapMutationSui = useMutation(async ({ id, route }) => {
         if (!route || !suiSigner || !fromChain) {
             throw new Error("Need all parameters");
         }
@@ -36057,7 +39390,7 @@ const useExecuteTransaction = (squidRoute) => {
             digest: txHash,
         });
     }, {});
-    const swapMutationStellar = reactQuery.useMutation(async ({ id, route }) => {
+    const swapMutationStellar = useMutation(async ({ id, route }) => {
         if (!stellarSigner || !route || !squid || !fromChain) {
             throw new Error("Need all parameters");
         }
@@ -36162,7 +39495,7 @@ const useExecuteTransaction = (squidRoute) => {
         setTransactionStoreState,
         squidRoute,
     ]);
-    const swapMutation = reactQuery.useMutation(async (mutationParams) => {
+    const swapMutation = useMutation(async (mutationParams) => {
         if (!mutationParams.route)
             throw new Error("route is required");
         const sourceChain = findChain(mutationParams.route.params?.fromChain);
@@ -36252,7 +39585,7 @@ const useGetRoute = () => {
     const config = useConfigStore((state) => state.config);
     const squid = useSquidStore((state) => state.squid);
     const { swapRoute } = useSwapRoutePersistStore();
-    const queryClient = reactQuery.useQueryClient();
+    const queryClient = useQueryClient();
     const previousParamsHashRef = React.useRef();
     /**
      * Dispatch event when requesting a quote for swap
@@ -36303,7 +39636,7 @@ const useGetRoute = () => {
      * These data will be used to trigger the transaction
      * @returns {Route} Route data
      */
-    return reactQuery.useMutation(async ({ fromChain, toChain, fromToken, toToken, sourceUserAddress, destinationAddress, fromPrice, bypassGuardrails, quoteOnly, fromChainType, postHook, preHook, overrideGasRefundAddress, }) => {
+    return useMutation(async ({ fromChain, toChain, fromToken, toToken, sourceUserAddress, destinationAddress, fromPrice, bypassGuardrails, quoteOnly, fromChainType, postHook, preHook, overrideGasRefundAddress, }) => {
         if (!fromChain || !toChain || !fromToken || !toToken || !fromPrice) {
             return undefined;
         }
@@ -36398,14 +39731,14 @@ refetchIntervalInBackground = false, refetchInterval = 30000, quoteOnly = true,
             fromPrice !== "0" &&
             toChain?.chainId !== undefined &&
             toToken?.address !== undefined;
-    const queryClient = reactQuery.useQueryClient();
+    const queryClient = useQueryClient();
     const cachedRouteData = queryClient.getQueryData(squidRouteQueryKeys);
     /**
      * Fetching route data from the API
      * These data will be used to trigger the transaction
      * @returns {Route} Route data
      */
-    const squidRoute = reactQuery.useQuery(squidRouteQueryKeys, async () => {
+    const squidRoute = useQuery(squidRouteQueryKeys, async () => {
         const route = await getRouteMutation.mutateAsync({
             fromChain: fromChain?.chainId,
             toChain: toChain?.chainId,
@@ -36465,7 +39798,7 @@ function useSendTransactionStatus({ chain, txHash, }) {
         transactionId: txHash,
         txType: exports.HistoryTxType.SEND,
     });
-    const { data: status } = reactQuery.useQuery({
+    const { data: status } = useQuery({
         queryKey: keys().sendTransactionStatus(txHash, chain?.chainId),
         queryFn: async () => {
             if (!chain || !txHash)
@@ -36540,7 +39873,7 @@ const useSwapTransactionStatus = ({ transaction, retry = 25, refetchOnWindowFocu
             apiUrl: latestConfig.apiUrl,
         });
     }, [transaction]);
-    const transactionStatusQuery = reactQuery.useQuery(keys().swapTransactionStatus(transaction?.transactionId), fetchTransactionStatusWithLatestConfig, {
+    const transactionStatusQuery = useQuery(keys().swapTransactionStatus(transaction?.transactionId), fetchTransactionStatusWithLatestConfig, {
         enabled: enabled &&
             transaction?.transactionId !== "0" &&
             !!transaction?.transactionId &&
@@ -36638,7 +39971,7 @@ const hashStringToIndex = (str, max) => {
  * @returns {string} - The selected avatar image URL.
  */
 const useAvatar = (seed = zeroAddress) => {
-    const { data: avatar } = reactQuery.useQuery({
+    const { data: avatar } = useQuery({
         queryKey: ["avatar", seed],
         queryFn: () => {
             const index = hashStringToIndex(seed, avatarImages.length);
@@ -36688,7 +40021,7 @@ const useAddToken = (chainToCompare, tokenToCompare) => {
     /**
      * Add token to wallet
      */
-    const addToken = reactQuery.useMutation(async ({ chain: _chain, token: _token, }) => {
+    const addToken = useMutation(async ({ chain: _chain, token: _token, }) => {
         const token = _token ?? tokenToCompare;
         const chain = _chain ?? chainToCompare;
         if (token && chain?.chainType === squidTypes.ChainType.EVM) {
@@ -36851,11 +40184,11 @@ const MAX_IOU_AMOUNT = "9999999999999999e80";
 const DEFAULT_REFETCH_INTERVAL = 20_000;
 function useXrplTrustLine({ address, chain, token, amount }) {
     const { xrplSigner } = useSigner({ chain });
-    const queryClient = reactQuery.useQueryClient();
+    const queryClient = useQueryClient();
     /**
      * Retrieves the destination account's trust line data for the given token
      */
-    const trustLineQuery = reactQuery.useQuery({
+    const trustLineQuery = useQuery({
         queryKey: keys().xrplTrustLine(token?.address, chain?.chainId, address),
         queryFn: async () => {
             if (chain?.chainType !== squidTypes.ChainType.XRPL ||
@@ -36865,12 +40198,12 @@ function useXrplTrustLine({ address, chain, token, amount }) {
             if (!address || !isXrplAddressValid(address)) {
                 return null;
             }
-            const trustLineAsset = parseXrplTokenAddress(token.address);
-            if (!trustLineAsset) {
+            const [currency, issuer] = token.address.split(".");
+            if (!currency || !issuer) {
                 return null;
             }
             const xrplClient = await getClient(chain);
-            const trustLine = await xrplClient.getTrustLine(address, trustLineAsset);
+            const trustLine = await xrplClient.getTrustLine(address, issuer, currency);
             return trustLine;
         },
         enabled: !!address &&
@@ -36881,7 +40214,7 @@ function useXrplTrustLine({ address, chain, token, amount }) {
     /**
      * Creates a trust line where the destination account authorizes to receive the given token
      */
-    const createTrustLine = reactQuery.useMutation({
+    const createTrustLine = useMutation({
         mutationFn: async () => {
             try {
                 if (!xrplSigner) {
@@ -36930,7 +40263,7 @@ function useXrplTrustLine({ address, chain, token, amount }) {
     /**
      * Checks if the destination account has created a trust line to receive the given token.
      */
-    const isTrustLineApproved = reactQuery.useQuery({
+    const isTrustLineApproved = useQuery({
         queryKey: keys().isXrplTrustLineApproved(address, token?.chainId, token?.type, token?.address, trustLineQuery.data?.limit, amount),
         queryFn: async () => {
             if (token?.type !== squidTypes.ChainType.XRPL) {
@@ -36958,7 +40291,7 @@ function useXrplTrustLine({ address, chain, token, amount }) {
      * Checks if the destination account is activated (holds at least the minimum XRP reserve balance)
      * XRPL accounts need to have a minimum balance before they can receive payments
      */
-    const accountActivatedInfo = reactQuery.useQuery({
+    const accountActivatedInfo = useQuery({
         queryKey: keys().xrplAccountActivatedInfo(address, chain?.chainId, chain?.chainType),
         queryFn: async () => {
             if (chain?.chainType !== squidTypes.ChainType.XRPL ||
@@ -37002,7 +40335,7 @@ const defaultOptions = {
     },
 };
 
-const queryClient = new reactQuery.QueryClient({ defaultOptions });
+const queryClient = new QueryClient({ defaultOptions });
 const verifyIntegratorIdValidity = (integratorId) => {
     if (!integratorId) {
         throw new Error("Integrator ID is required");
@@ -37098,7 +40431,7 @@ const SquidProvider = ({ children, config, placeholder, }) => {
         initializeSdk();
     }, [initializeSdk]);
     return wagmiConfig ? (React.createElement(wagmi.WagmiProvider, { reconnectOnMount: false, config: wagmiConfig },
-        React.createElement(reactQuery.QueryClientProvider, { client: queryClient },
+        React.createElement(QueryClientProvider, { client: queryClient },
             React.createElement(StellarProvider, null,
                 React.createElement(EvmProvider, null,
                     React.createElement(XrplProvider, null,
@@ -37196,9 +40529,6 @@ exports.getSecretNetworkBalances = getSecretNetworkBalances;
 exports.getSendTxStatusRefetchInterval = getSendTxStatusRefetchInterval;
 exports.getSourceExplorerTxUrl = getSourceExplorerTxUrl;
 exports.getStatusCode = getStatusCode;
-exports.getStellarHorizonApiUrl = getStellarHorizonApiUrl;
-exports.getStellarNetwork = getStellarNetwork;
-exports.getStellarTrustLineAsset = getStellarTrustLineAsset;
 exports.getStepStatuses = getStepStatuses;
 exports.getStepsInfos = getStepsInfos;
 exports.getSuggestedAmountsForCurrency = getSuggestedAmountsForCurrency;
@@ -37234,13 +40564,8 @@ exports.isHistoryTransactionWarning = isHistoryTransactionWarning;
 exports.isProblematicConnector = isProblematicConnector;
 exports.isSolanaAddressValid = isSolanaAddressValid;
 exports.isStatusError = isStatusError;
-exports.isStellarAddressValid = isStellarAddressValid;
-exports.isStellarIssuedToken = isStellarIssuedToken;
-exports.isStellarToken = isStellarToken;
 exports.isSwapRouteError = isSwapRouteError;
 exports.isUserRejectionError = isUserRejectionError;
-exports.isValidHorizonAsset = isValidHorizonAsset;
-exports.isValidIssuedAsset = isValidIssuedAsset;
 exports.isWalletAddressValid = isWalletAddressValid;
 exports.isXamanXAppContext = isXamanXAppContext;
 exports.isXionSmartContractAddress = isXionSmartContractAddress;
@@ -37259,7 +40584,6 @@ exports.normalizeTokenSymbol = normalizeTokenSymbol;
 exports.parseEvmAddress = parseEvmAddress;
 exports.parseToBigInt = parseToBigInt;
 exports.parseXrplPaymentTx = parseXrplPaymentTx;
-exports.parseXrplTokenAddress = parseXrplTokenAddress;
 exports.populateWallets = populateWallets;
 exports.randomIntFromInterval = randomIntFromInterval;
 exports.redirectToExtensionsStore = redirectToExtensionsStore;
@@ -37272,7 +40596,6 @@ exports.sortAddressBook = sortAddressBook;
 exports.sortAllTokens = sortAllTokens;
 exports.sortTokensBySharedSubgraphIds = sortTokensBySharedSubgraphIds;
 exports.sortWallets = sortWallets;
-exports.stellarAddressToScVal = stellarAddressToScVal;
 exports.suggestChainOrThrow = suggestChainOrThrow;
 exports.transactionErrorCode = transactionErrorCode;
 exports.trimExtraDecimals = trimExtraDecimals;
@@ -37338,7 +40661,6 @@ exports.useSquidQueryClient = useSquidQueryClient;
 exports.useSquidStore = useSquidStore;
 exports.useSquidTokens = useSquidTokens;
 exports.useStellarAccountActivation = useStellarAccountActivation;
-exports.useStellarTrustLine = useStellarTrustLine;
 exports.useSuggestedFiatAmounts = useSuggestedFiatAmounts;
 exports.useSwap = useSwap;
 exports.useSwapRoutePersistStore = useSwapRoutePersistStore;
@@ -37354,4 +40676,4 @@ exports.useXrplTrustLine = useXrplTrustLine;
 exports.waitForReceiptWithRetry = waitForReceiptWithRetry;
 exports.walletIconBaseUrl = walletIconBaseUrl;
 exports.walletSupportsChainType = walletSupportsChainType;
-//# sourceMappingURL=index-CJQHDfLM.js.map
+//# sourceMappingURL=index-DOoP75Yp.js.map