wagmi 0.2.21 → 0.3.0-next.0

package/dist/wagmi.cjs.dev.js

@@ -3,9 +3,11 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var React = require('react');
-var providers = require('@ethersproject/providers');
-var wagmiCore = require('wagmi-core');
-var ethers = require('ethers');
+var core = require('@wagmi/core');
+var reactQuery = require('react-query');
+var persistQueryClientExperimental = require('react-query/persistQueryClient-experimental');
+var createWebStoragePersistorExperimental = require('react-query/createWebStoragePersistor-experimental');
+var ethers = require('ethers/lib/ethers');
 
 function _interopNamespace(e) {
   if (e && e.__esModule) return e;
@@ -27,6 +29,76 @@ function _interopNamespace(e) {
 
 var React__namespace = /*#__PURE__*/_interopNamespace(React);
 
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+  try {
+    var info = gen[key](arg);
+    var value = info.value;
+  } catch (error) {
+    reject(error);
+    return;
+  }
+
+  if (info.done) {
+    resolve(value);
+  } else {
+    Promise.resolve(value).then(_next, _throw);
+  }
+}
+
+function _asyncToGenerator(fn) {
+  return function () {
+    var self = this,
+        args = arguments;
+    return new Promise(function (resolve, reject) {
+      var gen = fn.apply(self, args);
+
+      function _next(value) {
+        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+      }
+
+      function _throw(err) {
+        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+      }
+
+      _next(undefined);
+    });
+  };
+}
+
+function _objectWithoutPropertiesLoose(source, excluded) {
+  if (source == null) return {};
+  var target = {};
+  var sourceKeys = Object.keys(source);
+  var key, i;
+
+  for (i = 0; i < sourceKeys.length; i++) {
+    key = sourceKeys[i];
+    if (excluded.indexOf(key) >= 0) continue;
+    target[key] = source[key];
+  }
+
+  return target;
+}
+
+function _objectWithoutProperties(source, excluded) {
+  if (source == null) return {};
+  var target = _objectWithoutPropertiesLoose(source, excluded);
+  var key, i;
+
+  if (Object.getOwnPropertySymbols) {
+    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+
+    for (i = 0; i < sourceSymbolKeys.length; i++) {
+      key = sourceSymbolKeys[i];
+      if (excluded.indexOf(key) >= 0) continue;
+      if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+      target[key] = source[key];
+    }
+  }
+
+  return target;
+}
+
 function _defineProperty(obj, key, value) {
   if (key in obj) {
     Object.defineProperty(obj, key, {
@@ -68,1171 +140,922 @@ function _objectSpread2(target) {
   return target;
 }
 
-function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
-  try {
-    var info = gen[key](arg);
-    var value = info.value;
-  } catch (error) {
-    reject(error);
-    return;
+var findAndReplace = (cacheRef, _ref) => {
+  var {
+    find,
+    replace
+  } = _ref;
+
+  if (cacheRef && find(cacheRef)) {
+    return replace(cacheRef);
   }
 
-  if (info.done) {
-    resolve(value);
-  } else {
-    Promise.resolve(value).then(_next, _throw);
+  if (typeof cacheRef !== 'object') {
+    return cacheRef;
   }
-}
 
-function _asyncToGenerator(fn) {
-  return function () {
-    var self = this,
-        args = arguments;
-    return new Promise(function (resolve, reject) {
-      var gen = fn.apply(self, args);
+  if (Array.isArray(cacheRef)) {
+    return cacheRef.map(item => findAndReplace(item, {
+      find,
+      replace
+    }));
+  }
 
-      function _next(value) {
-        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
-      }
+  if (cacheRef instanceof Object) {
+    return Object.entries(cacheRef).reduce((curr, _ref2) => {
+      var [key, value] = _ref2;
+      return _objectSpread2(_objectSpread2({}, curr), {}, {
+        [key]: findAndReplace(value, {
+          find,
+          replace
+        })
+      });
+    }, {});
+  }
 
-      function _throw(err) {
-        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
-      }
+  return cacheRef;
+};
 
-      _next(undefined);
-    });
-  };
+function deserialize(cachedString) {
+  var cache = JSON.parse(cachedString);
+  var deserializedCacheWithBigNumbers = findAndReplace(cache, {
+    find: data => data.type === 'BigNumber',
+    replace: data => ethers.BigNumber.from(data.hex)
+  });
+  return deserializedCacheWithBigNumbers;
 }
 
-var useProvider = () => {
-  var {
-    state
-  } = useContext();
-  return state.provider;
-};
-
-var useWebSocketProvider = () => {
-  var {
-    state
-  } = useContext();
-  return state.webSocketProvider;
-};
+var LIMIT_REPLACE_NODE = '[...]';
+var CIRCULAR_REPLACE_NODE = '[Circular]';
+var arr = [];
+var replacerStack = [];
+var defaultOptions = {
+  depthLimit: Number.MAX_SAFE_INTEGER,
+  edgesLimit: Number.MAX_SAFE_INTEGER
+}; // Regular stringify
 
-var useCacheBuster = () => {
-  var context = useContext();
-  return context.state.cacheBuster;
-};
+function serialize(obj, replacer, spacer) {
+  var options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : defaultOptions;
+  decirc(obj, '', 0, [], undefined, 0, options);
+  var res;
 
-var useCancel = () => {
-  var cancelCallback = React__namespace.useRef(null);
-  React__namespace.useEffect(() => {
-    return () => {
-      var _cancelCallback$curre;
+  try {
+    if (replacerStack.length === 0) {
+      res = JSON.stringify(obj, replacer, spacer);
+    } else {
+      res = JSON.stringify(obj, replaceGetterValues(replacer), spacer);
+    }
+  } catch (_) {
+    return JSON.stringify('[unable to serialize, circular reference is too complex to analyze]');
+  } finally {
+    while (arr.length !== 0) {
+      var part = arr.pop();
+
+      if (part.length === 4) {
+        Object.defineProperty(part[0], part[1], part[3]);
+      } else {
+        part[0][part[1]] = part[2];
+      }
+    }
+  }
 
-      return (_cancelCallback$curre = cancelCallback.current) === null || _cancelCallback$curre === void 0 ? void 0 : _cancelCallback$curre.call(cancelCallback);
-    };
-  }, []);
-  var cancel = React__namespace.useCallback(callback => {
-    var _cancelCallback$curre2;
+  return res;
+}
 
-    (_cancelCallback$curre2 = cancelCallback.current) === null || _cancelCallback$curre2 === void 0 ? void 0 : _cancelCallback$curre2.call(cancelCallback);
-    if (callback) cancelCallback.current = callback;
-  }, []);
-  return cancel;
-};
+function setReplace(replace, val, k, parent) {
+  var propertyDescriptor = Object.getOwnPropertyDescriptor(parent, k);
 
-var useLocalStorage = function useLocalStorage(key) {
-  var defaultState = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
-  var [value, setValue] = React__namespace.useState(() => {
-    if (typeof localStorage === 'undefined') return defaultState;
-    var value = localStorage.getItem(key);
-
-    try {
-      return value ? JSON.parse(value) : defaultState;
-    } catch (error) {
-      console.warn(error);
-      return defaultState;
+  if ((propertyDescriptor === null || propertyDescriptor === void 0 ? void 0 : propertyDescriptor.get) !== undefined) {
+    if (propertyDescriptor.configurable) {
+      Object.defineProperty(parent, k, {
+        value: replace
+      });
+      arr.push([parent, k, val, propertyDescriptor]);
+    } else {
+      replacerStack.push([val, k, replace]);
     }
-  });
-  var setLocalStorage = React__namespace.useCallback(newValue => {
-    if (newValue === value) return;
-    setValue(newValue);
-    if (newValue === null) localStorage.removeItem(key);else localStorage.setItem(key, JSON.stringify(newValue));
+  } else {
+    parent[k] = replace;
+    arr.push([parent, k, val]);
+  }
+}
 
-    if (newValue === null) {
-      localStorage.removeItem(key);
-    } else {
-      try {
-        localStorage.setItem(key, JSON.stringify(newValue));
-      } catch (error) {
-        console.error(error);
+function decirc(val, k, edgeIndex, stack, parent, depth, options) {
+  depth += 1;
+  var i;
+
+  if (typeof val === 'object' && val !== null) {
+    for (i = 0; i < stack.length; i++) {
+      if (stack[i] === val) {
+        setReplace(CIRCULAR_REPLACE_NODE, val, k, parent);
+        return;
       }
     }
-  }, [value, setValue, key]);
-  return [value, setLocalStorage];
-};
-
-var initialState$g = {
-  loading: false
-};
-var useEnsAvatar = function useEnsAvatar() {
-  var {
-    addressOrName,
-    skip
-  } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-  var cacheBuster = useCacheBuster();
-  var provider = useProvider();
-  var [state, setState] = React__namespace.useState(initialState$g);
-  var cancelQuery = useCancel();
-  var getEnsAvatar = React__namespace.useCallback( /*#__PURE__*/function () {
-    var _ref = _asyncToGenerator(function* (config) {
-      var didCancel = false;
-      cancelQuery(() => {
-        didCancel = true;
-      });
 
-      try {
-        var config_ = config !== null && config !== void 0 ? config : {
-          addressOrName
-        };
-        if (!config_.addressOrName) throw new Error('addressOrName is required');
-        setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
-          error: undefined,
-          loading: true
-        }));
-        var avatar = yield provider.getAvatar(config_.addressOrName);
-
-        if (!didCancel) {
-          setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
-            avatar,
-            loading: false
-          }));
-        }
+    if (typeof options.depthLimit !== 'undefined' && depth > options.depthLimit) {
+      setReplace(LIMIT_REPLACE_NODE, val, k, parent);
+      return;
+    }
 
-        return avatar;
-      } catch (error_) {
-        var error = error_;
+    if (typeof options.edgesLimit !== 'undefined' && edgeIndex + 1 > options.edgesLimit) {
+      setReplace(LIMIT_REPLACE_NODE, val, k, parent);
+      return;
+    }
 
-        if (!didCancel) {
-          setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
-            error,
-            loading: false
-          }));
-        }
+    stack.push(val); // Optimize for Arrays. Big arrays could kill the performance otherwise!
 
-        return error;
+    if (Array.isArray(val)) {
+      for (i = 0; i < val.length; i++) {
+        decirc(val[i], i, i, stack, val, depth, options);
       }
-    });
+    } else {
+      var keys = Object.keys(val);
 
-    return function (_x) {
-      return _ref.apply(this, arguments);
-    };
-  }(), [addressOrName, cancelQuery, provider]); // Fetch avatar when deps or chain changes
+      for (i = 0; i < keys.length; i++) {
+        var _key = keys[i];
+        decirc(val[_key], _key, i, stack, val, depth, options);
+      }
+    }
 
-  /* eslint-disable react-hooks/exhaustive-deps */
+    stack.pop();
+  }
+}
 
-  React__namespace.useEffect(() => {
-    if (skip || !addressOrName) return;
-    getEnsAvatar({
-      addressOrName
-    });
-    return cancelQuery;
-  }, [addressOrName, cacheBuster, cancelQuery, skip]);
-  /* eslint-enable react-hooks/exhaustive-deps */
+// wraps replacer function to handle values we couldn't replace
+// and mark them as replaced value
+function replaceGetterValues() {
+  var replacer = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : (_k, v) => v;
+  return (key, val) => {
+    if (replacerStack.length > 0) {
+      for (var i = 0; i < replacerStack.length; i++) {
+        var part = replacerStack[i];
+
+        if (part[1] === key && part[0] === val) {
+          val = part[2];
+          replacerStack.splice(i, 1);
+          break;
+        }
+      }
+    }
 
-  return [{
-    data: state.avatar,
-    loading: state.loading,
-    error: state.error
-  }, getEnsAvatar];
-};
+    return replacer.apply(key, val);
+  };
+}
 
-var initialState$f = {
-  loading: false
+var _excluded$6 = ["queryClient"];
+var Context = /*#__PURE__*/React__namespace.createContext(undefined);
+var defaultQueryClientConfig = {
+  defaultOptions: {
+    queries: {
+      cacheTime: 1000 * 60 * 60 * 24,
+      // 24 hours
+      notifyOnChangeProps: 'tracked',
+      refetchOnWindowFocus: false,
+      retry: 0
+    }
+  }
 };
-var useEnsLookup = function useEnsLookup() {
+function createClient() {
+  var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+      {
+    queryClient = new reactQuery.QueryClient(defaultQueryClientConfig)
+  } = _ref,
+      config = _objectWithoutProperties(_ref, _excluded$6);
+
+  var client = core.createClient(config);
+  var persistor = createWebStoragePersistorExperimental.createWebStoragePersistor({
+    storage: client.storage || window.localStorage,
+    serialize,
+    deserialize
+  });
+  persistQueryClientExperimental.persistQueryClient({
+    queryClient,
+    persistor,
+    dehydrateOptions: {
+      shouldDehydrateQuery: query => query.cacheTime !== 0
+    }
+  });
+  return Object.assign(client, {
+    queryClient
+  });
+}
+function Provider(_ref2) {
   var {
-    address,
-    skip
-  } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-  var cacheBuster = useCacheBuster();
-  var provider = useProvider();
-  var [state, setState] = React__namespace.useState(initialState$f);
-  var cancelQuery = useCancel();
-  var lookupAddress = React__namespace.useCallback( /*#__PURE__*/function () {
-    var _ref = _asyncToGenerator(function* (config) {
-      var didCancel = false;
-      cancelQuery(() => {
-        didCancel = true;
-      });
-
-      try {
-        var config_ = config !== null && config !== void 0 ? config : {
-          address
-        };
-        if (!config_.address) throw new Error('address is required');
-        setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
-          error: undefined,
-          loading: true
-        }));
-        var ens = yield provider.lookupAddress(config_.address);
-
-        if (!didCancel) {
-          setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
-            ens,
-            loading: false
-          }));
-        }
+    children,
+    client = createClient()
+  } = _ref2;
+  // Attempt to connect on mount
 
-        return {
-          data: ens,
-          error: undefined
-        };
-      } catch (error_) {
-        var error = error_;
-
-        if (!didCancel) {
-          setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
-            error,
-            loading: false
-          }));
-        }
+  /* eslint-disable react-hooks/exhaustive-deps */
+  React__namespace.useEffect(() => {
 
-        return {
-          data: undefined,
-          error
-        };
-      }
-    });
+    _asyncToGenerator(function* () {
+      if (!client.config.autoConnect) return;
+      yield client.autoConnect();
+    })();
+  }, []);
+  /* eslint-enable react-hooks/exhaustive-deps */
 
-    return function (_x) {
-      return _ref.apply(this, arguments);
-    };
-  }(), [address, cancelQuery, provider]); // Resolve name when deps or chain changes
+  return /*#__PURE__*/React__namespace.createElement(Context.Provider, {
+    value: client
+  }, /*#__PURE__*/React__namespace.createElement(reactQuery.QueryClientProvider, {
+    client: client.queryClient
+  }, children));
+}
+function useClient() {
+  var client = React__namespace.useContext(Context);
+  if (!client) throw Error('Must be used within WagmiProvider');
+  return client;
+}
 
-  /* eslint-disable react-hooks/exhaustive-deps */
+function useProvider() {
+  var [, forceUpdate] = React__namespace.useReducer(c => c + 1, 0);
+  var client = useClient();
+  React__namespace.useEffect(() => {
+    var unsubscribe = client.subscribe(state => state.provider, forceUpdate);
+    return unsubscribe;
+  }, [client]);
+  return client.provider;
+}
 
+function useWebSocketProvider() {
+  var [, forceUpdate] = React__namespace.useReducer(c => c + 1, 0);
+  var client = useClient();
   React__namespace.useEffect(() => {
-    if (skip || !address) return;
-    lookupAddress({
-      address
-    });
-    return cancelQuery;
-  }, [address, cacheBuster, cancelQuery, skip]);
-  /* eslint-enable react-hooks/exhaustive-deps */
+    var unsubscribe = client.subscribe(state => state.webSocketProvider, forceUpdate);
+    return unsubscribe;
+  }, [client]);
+  return client.webSocketProvider;
+}
 
+function useChainId() {
+  var _provider$network;
+
+  var provider = useProvider();
+  return provider === null || provider === void 0 ? void 0 : (_provider$network = provider.network) === null || _provider$network === void 0 ? void 0 : _provider$network.chainId;
+}
+
+var queryKey$a = _ref => {
+  var {
+    chainId,
+    name
+  } = _ref;
   return [{
-    data: state.ens,
-    loading: state.loading,
-    error: state.error
-  }, lookupAddress];
+    entity: 'ensAddress',
+    chainId,
+    name
+  }];
 };
 
-var initialState$e = {
-  loading: false
+var queryFn$9 = _ref2 => {
+  var {
+    queryKey: [{
+      name
+    }]
+  } = _ref2;
+  if (!name) throw new Error('name is required');
+  return core.fetchEnsAddress({
+    name
+  });
 };
-var useEnsResolveName = function useEnsResolveName() {
+
+function useEnsAddress() {
   var {
     name,
-    skip
+    cacheTime,
+    enabled = true,
+    keepPreviousData,
+    select,
+    staleTime = 1000 * 60 * 60 * 24,
+    // 24 hours
+    suspense,
+    onError,
+    onSettled,
+    onSuccess
   } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-  var cacheBuster = useCacheBuster();
-  var provider = useProvider();
-  var [state, setState] = React__namespace.useState(initialState$e);
-  var cancelQuery = useCancel();
-  var resolveName = React__namespace.useCallback( /*#__PURE__*/function () {
-    var _ref = _asyncToGenerator(function* (config) {
-      var didCancel = false;
-      cancelQuery(() => {
-        didCancel = true;
-      });
+  var chainId = useChainId();
+  return reactQuery.useQuery(queryKey$a({
+    chainId,
+    name
+  }), queryFn$9, {
+    cacheTime,
+    enabled: Boolean(enabled && chainId && name),
+    keepPreviousData,
+    select,
+    staleTime,
+    suspense,
+    onError,
+    onSettled,
+    onSuccess
+  });
+}
 
-      try {
-        var config_ = config !== null && config !== void 0 ? config : {
-          name
-        };
-        if (!config_.name) throw new Error('name is required');
-        setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
-          error: undefined,
-          loading: true
-        }));
-        var address = yield provider.resolveName(config_.name);
-
-        if (!didCancel) {
-          setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
-            address,
-            loading: false
-          }));
-        }
+var queryKey$9 = _ref => {
+  var {
+    addressOrName,
+    chainId
+  } = _ref;
+  return [{
+    entity: 'ensAvatar',
+    addressOrName,
+    chainId
+  }];
+};
 
-        return {
-          data: address,
-          error: undefined
-        };
-      } catch (error_) {
-        var error = error_;
-
-        if (!didCancel) {
-          setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
-            error,
-            loading: false
-          }));
-        }
+var queryFn$8 = _ref2 => {
+  var {
+    queryKey: [{
+      addressOrName
+    }]
+  } = _ref2;
+  if (!addressOrName) throw new Error('addressOrName is required');
+  return core.fetchEnsAvatar({
+    addressOrName
+  });
+};
 
-        return {
-          data: undefined,
-          error
-        };
-      }
-    });
+function useEnsAvatar() {
+  var {
+    addressOrName,
+    cacheTime,
+    enabled = true,
+    keepPreviousData,
+    select,
+    staleTime = 1000 * 60 * 60 * 24,
+    // 24 hours
+    suspense,
+    onError,
+    onSettled,
+    onSuccess
+  } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var chainId = useChainId();
+  return reactQuery.useQuery(queryKey$9({
+    addressOrName,
+    chainId
+  }), queryFn$8, {
+    cacheTime,
+    enabled: Boolean(enabled && addressOrName && chainId),
+    keepPreviousData,
+    select,
+    staleTime,
+    suspense,
+    onError,
+    onSettled,
+    onSuccess
+  });
+}
 
-    return function (_x) {
-      return _ref.apply(this, arguments);
-    };
-  }(), [name, cancelQuery, provider]); // Resolve name when deps or chain changes
+var queryKey$8 = _ref => {
+  var {
+    address,
+    chainId
+  } = _ref;
+  return [{
+    entity: 'ensName',
+    address,
+    chainId
+  }];
+};
 
-  /* eslint-disable react-hooks/exhaustive-deps */
+var queryFn$7 = _ref2 => {
+  var {
+    queryKey: [{
+      address
+    }]
+  } = _ref2;
+  if (!address) throw new Error('address is required');
+  return core.fetchEnsName({
+    address
+  });
+};
 
-  React__namespace.useEffect(() => {
-    if (skip || !name) return;
-    resolveName({
-      name
-    });
-    return cancelQuery;
-  }, [name, cacheBuster, cancelQuery, skip]);
-  /* eslint-enable react-hooks/exhaustive-deps */
+function useEnsName() {
+  var {
+    address,
+    cacheTime,
+    enabled = true,
+    keepPreviousData,
+    select,
+    staleTime = 1000 * 60 * 60 * 24,
+    // 24 hours
+    suspense,
+    onError,
+    onSettled,
+    onSuccess
+  } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var chainId = useChainId();
+  return reactQuery.useQuery(queryKey$8({
+    address,
+    chainId
+  }), queryFn$7, {
+    cacheTime,
+    enabled: Boolean(enabled && address && chainId),
+    keepPreviousData,
+    select,
+    staleTime,
+    suspense,
+    onError,
+    onSettled,
+    onSuccess
+  });
+}
 
+var queryKey$7 = _ref => {
+  var {
+    chainId,
+    name
+  } = _ref;
   return [{
-    data: state.address,
-    loading: state.loading,
-    error: state.error
-  }, resolveName];
+    entity: 'ensResolver',
+    chainId,
+    name
+  }];
 };
 
-var initialState$d = {
-  loading: false
+var queryFn$6 = _ref2 => {
+  var {
+    queryKey: [{
+      name
+    }]
+  } = _ref2;
+  if (!name) throw new Error('name is required');
+  return core.fetchEnsResolver({
+    name
+  });
 };
-var useEnsResolver = function useEnsResolver() {
+
+function useEnsResolver() {
   var {
     name,
-    skip
+    cacheTime,
+    enabled = true,
+    keepPreviousData,
+    select,
+    staleTime = 1000 * 60 * 60 * 24,
+    // 24 hours
+    suspense,
+    onError,
+    onSettled,
+    onSuccess
   } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-  var cacheBuster = useCacheBuster();
-  var provider = useProvider();
-  var [state, setState] = React__namespace.useState(initialState$d);
-  var cancelQuery = useCancel();
-  var getEnsResolver = React__namespace.useCallback( /*#__PURE__*/function () {
-    var _ref = _asyncToGenerator(function* (config) {
-      var didCancel = false;
-      cancelQuery(() => {
-        didCancel = true;
-      });
-
-      try {
-        var config_ = config !== null && config !== void 0 ? config : {
-          name
-        };
-        if (!config_.name) throw new Error('name is required');
-        setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
-          error: undefined,
-          loading: true
-        }));
-        var resolver = yield provider.getResolver(config_.name);
-
-        if (!didCancel) {
-          setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
-            loading: false,
-            resolver
-          }));
-        }
-
-        return {
-          data: resolver,
-          error: undefined
-        };
-      } catch (error_) {
-        var error = error_;
-
-        if (!didCancel) {
-          setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
-            error,
-            loading: false
-          }));
-        }
+  var chainId = useChainId();
+  return reactQuery.useQuery(queryKey$7({
+    chainId,
+    name
+  }), queryFn$6, {
+    cacheTime,
+    enabled: Boolean(enabled && chainId && name),
+    keepPreviousData,
+    select,
+    staleTime,
+    suspense,
+    onError,
+    onSettled,
+    onSuccess
+  });
+}
 
-        return {
-          data: undefined,
-          error
-        };
-      }
-    });
+var _excluded$5 = ["data", "error", "isError", "isLoading", "status"];
+var queryKey$6 = () => [{
+  entity: 'account'
+}];
+function useAccount() {
+  var {
+    ens,
+    cacheTime,
+    enabled = true,
+    keepPreviousData,
+    select,
+    staleTime,
+    suspense,
+    onError,
+    onSettled,
+    onSuccess
+  } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var client = useClient();
+  var queryClient = reactQuery.useQueryClient();
 
-    return function (_x) {
-      return _ref.apply(this, arguments);
+  var _useQuery = reactQuery.useQuery(queryKey$6(), () => {
+    var {
+      address,
+      connector
+    } = core.getAccount();
+    var cachedAccount = queryClient.getQueryData(queryKey$6());
+    return address ? {
+      address,
+      connector
+    } : cachedAccount || {
+      address: undefined,
+      connector: undefined
     };
-  }(), [cancelQuery, name, provider]); // Fetch avatar when deps or chain changes
-
-  /* eslint-disable react-hooks/exhaustive-deps */
-
-  React__namespace.useEffect(() => {
-    if (skip || !name) return;
-    getEnsResolver({
-      name
-    });
-    return cancelQuery;
-  }, [cacheBuster, cancelQuery, name, skip]);
-  /* eslint-enable react-hooks/exhaustive-deps */
-
-  return [{
-    data: state.resolver,
-    loading: state.loading,
-    error: state.error
-  }, getEnsResolver];
-};
-
-var useAccount = function useAccount() {
-  var _globalState$data;
+  }, {
+    cacheTime,
+    enabled,
+    keepPreviousData,
+    select,
+    staleTime,
+    suspense,
+    onError,
+    onSettled,
+    onSuccess
+  }),
+      {
+    data: accountData,
+    error,
+    isError,
+    isLoading,
+    status
+  } = _useQuery,
+      accountQueryResult = _objectWithoutProperties(_useQuery, _excluded$5);
 
+  var address = accountData === null || accountData === void 0 ? void 0 : accountData.address;
   var {
-    fetchEns
-  } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    data: ensAvatarData
+  } = useEnsAvatar({
+    addressOrName: address,
+    enabled: Boolean(typeof ens === 'boolean' ? ens : ens === null || ens === void 0 ? void 0 : ens.avatar)
+  });
   var {
-    state: globalState,
-    setState
-  } = useContext();
-  var address = (_globalState$data = globalState.data) === null || _globalState$data === void 0 ? void 0 : _globalState$data.account;
-  var [{
-    data: ens,
-    error: ensError,
-    loading: ensLoading
-  }] = useEnsLookup({
+    data: ensNameData
+  } = useEnsName({
     address,
-    skip: !fetchEns
-  });
-  var [{
-    data: avatar,
-    error: avatarError,
-    loading: avatarLoading
-  }] = useEnsAvatar({
-    addressOrName: ens,
-    skip: !fetchEns || !ens
+    enabled: Boolean(typeof ens === 'boolean' ? ens : ens === null || ens === void 0 ? void 0 : ens.name)
   });
-  var disconnect = React__namespace.useCallback(() => {
-    setState(x => {
-      var _x$connector;
-
-      (_x$connector = x.connector) === null || _x$connector === void 0 ? void 0 : _x$connector.disconnect();
-      return {
-        cacheBuster: x.cacheBuster + 1
-      };
+  React__namespace.useEffect(() => {
+    var unwatch = core.watchAccount(data => {
+      queryClient.setQueryData(queryKey$6(), data);
     });
-  }, [setState]);
-  var error = ensError || avatarError;
-  var loading = ensLoading || avatarLoading;
-  return [{
-    data: address ? {
-      address,
-      connector: globalState.connector,
-      ens: ens ? {
-        avatar,
-        name: ens
-      } : undefined
-    } : undefined,
+    return unwatch;
+  }, [queryClient]); // Force data to be undefined if no address exists
+
+  var data_ = address ? accountData : undefined;
+  var isLoading_ = isLoading || client.status === 'connecting';
+  var status_;
+  if (isLoading_) status_ = 'loading';else if (!address) status_ = 'idle';else status_ = status;
+  var ensData = ensNameData !== undefined || ensAvatarData !== undefined ? {
+    ens: {
+      avatar: ensAvatarData,
+      name: ensNameData
+    }
+  } : {};
+  return _objectSpread2(_objectSpread2({}, accountQueryResult), {}, {
+    data: data_ ? _objectSpread2(_objectSpread2({}, data_), ensData) : undefined,
+    disconnect: core.disconnect,
     error,
-    loading
-  }, disconnect];
+    isError,
+    isIdle: status_ === 'idle',
+    isLoading: status_ === 'loading',
+    isSuccess: status_ === 'success',
+    status: status_
+  });
+}
+
+var queryKey$5 = _ref => {
+  var {
+    chainId
+  } = _ref;
+  return [{
+    entity: 'blockNumber',
+    chainId
+  }];
 };
 
-var initialState$c = {
-  loading: false
+var queryFn$5 = () => {
+  return core.fetchBlockNumber();
 };
-var useBlockNumber = function useBlockNumber() {
+
+function useBlockNumber() {
   var {
-    skip,
-    watch
+    cacheTime = 0,
+    enabled = true,
+    keepPreviousData,
+    select,
+    staleTime,
+    suspense,
+    onError,
+    onSettled,
+    onSuccess,
+    watch = false
   } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-  var cacheBuster = useCacheBuster();
+  var chainId = useChainId();
   var provider = useProvider();
   var webSocketProvider = useWebSocketProvider();
-  var [state, setState] = React__namespace.useState(initialState$c);
-  var cancelQuery = useCancel();
-  var getBlockNumber = React__namespace.useCallback( /*#__PURE__*/_asyncToGenerator(function* () {
-    var didCancel = false;
-    cancelQuery(() => {
-      didCancel = true;
-    });
-
-    try {
-      setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
-        error: undefined,
-        loading: true
-      }));
-      var blockNumber = yield provider.getBlockNumber();
-
-      if (!didCancel) {
-        setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
-          blockNumber,
-          loading: false
-        }));
-      }
-
-      return {
-        data: blockNumber,
-        error: undefined
-      };
-    } catch (error_) {
-      var error = error_;
-
-      if (!didCancel) {
-        setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
-          error,
-          loading: false
-        }));
-      }
-
-      return {
-        data: undefined,
-        error
-      };
-    }
-  }), [cancelQuery, provider]);
-  /* eslint-disable react-hooks/exhaustive-deps */
-
-  React__namespace.useEffect(() => {
-    if (skip) return;
-    getBlockNumber();
-    return cancelQuery;
-  }, [cacheBuster, cancelQuery, skip]);
-  /* eslint-enable react-hooks/exhaustive-deps */
+  var queryClient = reactQuery.useQueryClient(); // console.log({ webSocketProvider, provider })
 
   React__namespace.useEffect(() => {
     if (!watch) return;
-    var didCancel = false;
 
     var listener = blockNumber => {
       // Just to be safe in case the provider implementation
       // calls the event callback after .off() has been called
-      if (!didCancel) {
-        setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
-          blockNumber
-        }));
-      }
+      queryClient.setQueryData(queryKey$5({
+        chainId
+      }), blockNumber);
     };
 
-    var provider_ = webSocketProvider !== null && webSocketProvider !== void 0 ? webSocketProvider : provider;
+    var provider_ = webSocketProvider !== null && webSocketProvider !== void 0 ? webSocketProvider : provider; // console.log({ provider_ })
+
     provider_.on('block', listener);
     return () => {
-      didCancel = true;
       provider_.off('block', listener);
     };
-  }, [provider, watch, webSocketProvider]);
+  }, [chainId, provider, queryClient, watch, webSocketProvider]);
+  return reactQuery.useQuery(queryKey$5({
+    chainId
+  }), queryFn$5, {
+    cacheTime,
+    enabled,
+    keepPreviousData,
+    select,
+    staleTime,
+    suspense,
+    onError,
+    onSettled,
+    onSuccess
+  });
+}
+
+var queryKey$4 = _ref => {
+  var {
+    addressOrName,
+    chainId,
+    formatUnits,
+    token
+  } = _ref;
   return [{
-    data: state.blockNumber,
-    error: state.error,
-    loading: state.loading
-  }, getBlockNumber];
+    entity: 'balance',
+    addressOrName,
+    chainId,
+    formatUnits,
+    token
+  }];
 };
 
-var initialState$b = {
-  loading: false
-};
-var useFeeData = function useFeeData() {
+var queryFn$4 = _ref2 => {
   var {
-    formatUnits = 'wei',
-    skip,
-    watch
-  } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-  var provider = useProvider();
-  var [{
-    data: blockNumber
-  }] = useBlockNumber({
-    skip: true,
-    watch
+    queryKey: [{
+      addressOrName,
+      formatUnits,
+      token
+    }]
+  } = _ref2;
+  if (!addressOrName) throw new Error('address is required');
+  return core.fetchBalance({
+    addressOrName,
+    formatUnits,
+    token
   });
-  var cacheBuster = useCacheBuster();
-  var [state, setState] = React__namespace.useState(initialState$b);
-  var cancelQuery = useCancel();
-  var getFeeData = React__namespace.useCallback( /*#__PURE__*/_asyncToGenerator(function* () {
-    var didCancel = false;
-    cancelQuery(() => {
-      didCancel = true;
-    });
-
-    try {
-      setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
-        error: undefined,
-        loading: true
-      }));
-      var feeData = yield provider.getFeeData();
-
-      if (!didCancel) {
-        setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
-          feeData,
-          loading: false
-        }));
-      }
-
-      return {
-        data: feeData,
-        error: undefined
-      };
-    } catch (error_) {
-      var error = error_;
-
-      if (!didCancel) {
-        setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
-          error,
-          loading: false
-        }));
-      }
-
-      return {
-        data: undefined,
-        error
-      };
-    }
-  }), [cancelQuery, provider]); // Fetch feeData on mount or when chain changes
-
-  /* eslint-disable react-hooks/exhaustive-deps */
-
-  React__namespace.useEffect(() => {
-    if (skip) return;
-    getFeeData();
-    return cancelQuery;
-  }, [cacheBuster, cancelQuery, skip]);
-  /* eslint-enable react-hooks/exhaustive-deps */
-
-  React__namespace.useEffect(() => {
-    if (!watch || !blockNumber) return;
-    getFeeData();
-    return cancelQuery;
-  }, [blockNumber, cancelQuery, getFeeData, watch]);
-  var formatted = state.feeData ? {
-    gasPrice: ethers.utils.formatUnits(state.feeData.gasPrice, formatUnits),
-    maxFeePerGas: ethers.utils.formatUnits(state.feeData.maxFeePerGas, formatUnits),
-    maxPriorityFeePerGas: ethers.utils.formatUnits(state.feeData.maxPriorityFeePerGas, formatUnits)
-  } : undefined;
-  return [{
-    data: state.feeData ? _objectSpread2(_objectSpread2({}, state.feeData), {}, {
-      formatted
-    }) : undefined,
-    loading: state.loading,
-    error: state.error
-  }, getFeeData];
 };
 
-var initialState$a = {
-  loading: false
-};
-var useBalance = function useBalance() {
+function useBalance() {
   var {
     addressOrName,
     formatUnits = 'ether',
-    skip,
     token,
-    watch
+    watch,
+    cacheTime,
+    enabled = true,
+    keepPreviousData,
+    select,
+    staleTime,
+    suspense,
+    onError,
+    onSettled,
+    onSuccess
   } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var chainId = useChainId();
+  var balanceQuery = reactQuery.useQuery(queryKey$4({
+    addressOrName,
+    chainId,
+    formatUnits,
+    token
+  }), queryFn$4, {
+    cacheTime,
+    enabled: Boolean(enabled && addressOrName),
+    keepPreviousData,
+    select,
+    staleTime,
+    suspense,
+    onError,
+    onSettled,
+    onSuccess
+  });
   var {
-    state: {
-      connector
-    }
-  } = useContext();
-  var cacheBuster = useCacheBuster();
-  var provider = useProvider();
-  var [{
     data: blockNumber
-  }] = useBlockNumber({
-    skip: true,
+  } = useBlockNumber({
     watch
   });
-  var [state, setState] = React__namespace.useState(initialState$a);
-  var cancelQuery = useCancel();
-  var getBalance = React__namespace.useCallback( /*#__PURE__*/function () {
-    var _ref = _asyncToGenerator(function* (config) {
-      var didCancel = false;
-      cancelQuery(() => {
-        didCancel = true;
-      });
-
-      try {
-        var _connector$chains;
-
-        var config_ = config !== null && config !== void 0 ? config : {
-          addressOrName,
-          formatUnits,
-          token
-        };
-        if (!config_.addressOrName) throw new Error('address is required');
-        setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
-          error: undefined,
-          loading: true
-        }));
-        var balance = yield wagmiCore.balanceAction({
-          chains: [...((_connector$chains = connector === null || connector === void 0 ? void 0 : connector.chains) !== null && _connector$chains !== void 0 ? _connector$chains : []), ...wagmiCore.defaultChains, ...wagmiCore.defaultL2Chains],
-          config: config_,
-          provider
-        });
-        if (!didCancel) setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
-          balance,
-          loading: false
-        }));
-        return {
-          data: balance,
-          error: undefined
-        };
-      } catch (error_) {
-        var error = error_;
-        if (!didCancel) setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
-          error,
-          loading: false
-        }));
-        return {
-          data: undefined,
-          error
-        };
-      }
-    });
-
-    return function (_x) {
-      return _ref.apply(this, arguments);
-    };
-  }(), [addressOrName, cancelQuery, connector, formatUnits, provider, token]); // Fetch balance when deps or chain changes
-
-  /* eslint-disable react-hooks/exhaustive-deps */
-
-  React__namespace.useEffect(() => {
-    if (skip || !addressOrName) return;
-    getBalance({
-      addressOrName,
-      formatUnits,
-      token
-    });
-    return cancelQuery;
-  }, [addressOrName, cacheBuster, cancelQuery, skip, token]);
-  /* eslint-enable react-hooks/exhaustive-deps */
-
-  /* eslint-disable react-hooks/exhaustive-deps */
-
   React__namespace.useEffect(() => {
+    if (!enabled) return;
     if (!watch) return;
     if (!blockNumber) return;
     if (!addressOrName) return;
-    getBalance({
-      addressOrName,
-      formatUnits,
-      token
-    });
+    balanceQuery.refetch(); // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [blockNumber]);
-  /* eslint-enable react-hooks/exhaustive-deps */
+  return balanceQuery;
+}
 
-  return [{
-    data: state.balance,
-    error: state.error,
-    loading: state.loading
-  }, getBalance];
-};
+var _excluded$4 = ["mutate", "mutateAsync", "status", "variables", "isSuccess", "isLoading"];
+var mutationKey$4 = 'connect';
 
-var initialState$9 = {
-  loading: false
-};
-var useConnect = () => {
-  var _globalState$data;
+var mutationFn$2 = connector => core.connect(connector);
 
+function useConnect() {
   var {
-    state: globalState,
-    setState: setGlobalState,
-    setLastUsedConnector
-  } = useContext();
-  var [state, setState] = React__namespace.useState(initialState$9);
-  var cancelQuery = useCancel();
-  var connect = React__namespace.useCallback( /*#__PURE__*/function () {
-    var _ref = _asyncToGenerator(function* (connector) {
-      var didCancel = false;
-      cancelQuery(() => {
-        didCancel = true;
-      });
-
-      try {
-        var activeConnector = globalState === null || globalState === void 0 ? void 0 : globalState.connector;
-        if (connector === activeConnector) throw new wagmiCore.ConnectorAlreadyConnectedError();
-        setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
-          loading: true,
-          connector,
-          error: undefined
-        }));
-        var data = yield connector.connect();
-
-        if (!didCancel) {
-          // Update connector globally only after successful connection
-          setGlobalState(x => _objectSpread2(_objectSpread2({}, x), {}, {
-            connector,
-            data
-          }));
-          setLastUsedConnector(connector.name);
-          setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
-            loading: false
-          }));
-        }
-
-        return {
-          data,
-          error: undefined
-        };
-      } catch (error_) {
-        var error = error_;
-
-        if (!didCancel) {
-          setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
-            connector: undefined,
-            error,
-            loading: false
-          }));
-        }
-
-        return {
-          data: undefined,
-          error
-        };
-      }
-    });
+    onBeforeConnect,
+    onConnect,
+    onError,
+    onSettled
+  } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var [, forceUpdate] = React__namespace.useReducer(c => c + 1, 0);
+  var client = useClient();
+
+  var _useMutation = reactQuery.useMutation(mutationKey$4, mutationFn$2, {
+    onError,
+    onMutate: onBeforeConnect,
+    onSettled,
+    onSuccess: onConnect
+  }),
+      {
+    mutate,
+    mutateAsync,
+    status,
+    variables: connector,
+    // Remove these values from return
+
+    /* eslint-disable @typescript-eslint/no-unused-vars */
+    isSuccess,
+    isLoading
+  } = _useMutation,
+      connectMutation = _objectWithoutProperties(_useMutation, _excluded$4); // Trigger update when connector or status change
 
-    return function (_x) {
-      return _ref.apply(this, arguments);
-    };
-  }(), [cancelQuery, globalState.connector, setGlobalState, setLastUsedConnector]); // Keep connector in sync with global connector
 
   React__namespace.useEffect(() => {
-    setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
-      connector: globalState.connector,
-      error: undefined
-    }));
-    return cancelQuery;
-  }, [cancelQuery, globalState.connector]);
-  return [{
-    data: {
-      connected: !!((_globalState$data = globalState.data) !== null && _globalState$data !== void 0 && _globalState$data.account),
+    var unsubscribe = client.subscribe(state => ({
       connector: state.connector,
-      connectors: globalState.connectors
-    },
-    error: state.error,
-    loading: state.loading || globalState.connecting
-  }, connect];
-};
-
-var initialState$8 = {
-  loading: false
-};
-var useNetwork = () => {
-  var _data$chain, _data$chain2, _connector$chains;
-
-  var {
-    state: {
-      connector,
-      data
-    }
-  } = useContext();
-  var [state, setState] = React__namespace.useState(initialState$8);
-  var chainId = data === null || data === void 0 ? void 0 : (_data$chain = data.chain) === null || _data$chain === void 0 ? void 0 : _data$chain.id;
-  var unsupported = data === null || data === void 0 ? void 0 : (_data$chain2 = data.chain) === null || _data$chain2 === void 0 ? void 0 : _data$chain2.unsupported;
-  var activeChains = (_connector$chains = connector === null || connector === void 0 ? void 0 : connector.chains) !== null && _connector$chains !== void 0 ? _connector$chains : [];
-  var activeChain = [...activeChains, ...wagmiCore.allChains].find(x => x.id === chainId);
-  var cancelQuery = useCancel();
-  var switchNetwork = React__namespace.useCallback( /*#__PURE__*/function () {
-    var _ref = _asyncToGenerator(function* (chainId) {
-      var didCancel = false;
-      cancelQuery(() => {
-        didCancel = true;
-      });
-      if (!(connector !== null && connector !== void 0 && connector.switchChain)) return {
-        data: undefined,
-        error: new wagmiCore.SwitchChainError()
-      };
-
-      try {
-        setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
-          error: undefined,
-          loading: true
-        }));
-        var chain = yield connector.switchChain(chainId);
-
-        if (!didCancel) {
-          setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
-            loading: false
-          }));
-        }
-
-        return {
-          data: chain,
-          error: undefined
-        };
-      } catch (error_) {
-        var error = error_;
-
-        if (!didCancel) {
-          setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
-            error,
-            loading: false
-          }));
-        }
-
-        return {
-          data: undefined,
-          error
-        };
-      }
-    });
-
-    return function (_x) {
-      return _ref.apply(this, arguments);
-    };
-  }(), [cancelQuery, connector]);
-  return [{
-    data: {
-      chain: chainId ? _objectSpread2(_objectSpread2({}, activeChain), {}, {
-        id: chainId,
-        unsupported
-      }) : undefined,
-      chains: activeChains
-    },
-    error: state.error,
-    loading: state.loading
-  }, connector !== null && connector !== void 0 && connector.switchChain ? switchNetwork : undefined];
-};
-
-var initialState$7 = {
-  data: undefined,
-  error: undefined,
-  loading: false
-};
-var useSigner = function useSigner() {
-  var {
-    skip
-  } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-  var cacheBuster = useCacheBuster();
-  var {
-    state: {
-      connector
-    }
-  } = useContext();
-  var [state, setState] = React__namespace.useState(initialState$7);
-  var cancelQuery = useCancel();
-  var getSigner = React__namespace.useCallback( /*#__PURE__*/_asyncToGenerator(function* () {
-    var didCancel = false;
-    cancelQuery(() => {
-      didCancel = true;
+      status: state.status
+    }), forceUpdate, {
+      equalityFn: (selected, previous) => selected.status === previous.status && selected.connector === previous.connector
     });
+    return unsubscribe;
+  }, [client]);
+  var status_;
+  if (client.status === 'reconnecting') status_ = 'reconnecting';else if (status === 'loading' || client.status === 'connecting') status_ = 'connecting';else if (status === 'success' || !!client.connector) status_ = 'connected';else if (!client.connector) status_ = 'disconnected';else status_ = status;
+  return _objectSpread2(_objectSpread2({}, connectMutation), {}, {
+    activeConnector: client.connector,
+    connect: mutate,
+    connectAsync: mutateAsync,
+    connector,
+    connectors: client.connectors,
+    isConnected: status_ === 'connected',
+    isConnecting: status_ === 'connecting',
+    isDisconnected: status_ === 'disconnected',
+    isIdle: status_ === 'idle',
+    isReconnecting: status_ === 'reconnecting',
+    status: status_
+  });
+}
 
-    try {
-      setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
-        error: undefined,
-        loading: true
-      }));
-      var signer = yield connector === null || connector === void 0 ? void 0 : connector.getSigner();
-
-      if (!didCancel) {
-        setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
-          data: signer,
-          loading: false
-        }));
-      }
-
-      return signer;
-    } catch (error_) {
-      var error = error_;
-
-      if (!didCancel) {
-        setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
-          data: undefined,
-          error,
-          loading: false
-        }));
-      }
-    }
-  }), [cancelQuery, connector]);
-  /* eslint-disable react-hooks/exhaustive-deps */
-
-  React__namespace.useEffect(() => {
-    if (skip) return;
-    getSigner();
-    return cancelQuery;
-  }, [cacheBuster, connector, cancelQuery, skip]);
-  /* eslint-enable react-hooks/exhaustive-deps */
-
-  return [state, getSigner];
-};
-
-var initialState$6 = {
-  loading: false
-};
-var useSignMessage = function useSignMessage() {
-  var {
-    message
-  } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-  var {
-    state: {
-      connector
-    }
-  } = useContext();
-  var [state, setState] = React__namespace.useState(initialState$6);
-  var cancelQuery = useCancel();
-  var signMessage = React__namespace.useCallback( /*#__PURE__*/function () {
-    var _ref = _asyncToGenerator(function* (config) {
-      var didCancel = false;
-      cancelQuery(() => {
-        didCancel = true;
-      });
-
-      try {
-        var config_ = config !== null && config !== void 0 ? config : {
-          message
-        };
-        if (!config_.message) throw new Error('message is required');
-        if (!connector) throw new wagmiCore.ConnectorNotFoundError();
-        setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
-          error: undefined,
-          loading: true
-        }));
-        var signer = yield connector.getSigner();
-        var signature = yield signer.signMessage(config_.message);
-
-        if (!didCancel) {
-          setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
-            signature,
-            loading: false
-          }));
-        }
-
-        return {
-          data: signature,
-          error: undefined
-        };
-      } catch (error_) {
-        var error = error_;
-        if (error_.code === 4001) error = new wagmiCore.UserRejectedRequestError();
-
-        if (!didCancel) {
-          setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
-            error,
-            loading: false
-          }));
-        }
+var _excluded$3 = ["mutate", "mutateAsync", "variables"];
+var mutationKey$3 = 'switchNetwork';
+var queryKey$3 = () => [{
+  entity: 'chain'
+}];
 
-        return {
-          data: undefined,
-          error
-        };
-      }
-    });
+var queryFn$3 = () => core.getNetwork();
 
-    return function (_x) {
-      return _ref.apply(this, arguments);
-    };
-  }(), [cancelQuery, connector, message]);
-  return [{
-    data: state.signature,
-    error: state.error,
-    loading: state.loading
-  }, signMessage];
-};
+function useNetwork() {
+  var _queryResult$data, _queryResult$data$cha, _queryResult$data2;
 
-var initialState$5 = {
-  loading: false
-};
-var useSignTypedData = function useSignTypedData() {
   var {
-    domain,
-    types,
-    value
+    onError,
+    onMutate,
+    onSettled,
+    onSuccess
   } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-  var {
-    state: {
-      connector
-    }
-  } = useContext();
-  var [state, setState] = React__namespace.useState(initialState$5);
-  var cancelQuery = useCancel();
-  var signTypedData = React__namespace.useCallback( /*#__PURE__*/function () {
-    var _ref = _asyncToGenerator(function* (config) {
-      var didCancel = false;
-      cancelQuery(() => {
-        didCancel = true;
-      });
-
-      try {
-        var config_ = config !== null && config !== void 0 ? config : {
-          domain,
-          types,
-          value
-        };
-        if (!config_.domain) throw new Error('domain is required');
-        if (!config_.types) throw new Error('type is required');
-        if (!config_.value) throw new Error('value is required');
-        if (!connector) throw new wagmiCore.ConnectorNotFoundError();
-        setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
-          error: undefined,
-          loading: true
-        }));
-        var signer = yield connector.getSigner(); // Method name may be changed in the future, see https://docs.ethers.io/v5/api/signer/#Signer-signTypedData
-
-        var signature = yield signer._signTypedData(config_.domain, config_.types, config_.value);
-
-        if (!didCancel) {
-          setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
-            signature,
-            loading: false
-          }));
-        }
+  var [, forceUpdate] = React__namespace.useReducer(c => c + 1, 0);
+  var client = useClient();
+  var queryClient = reactQuery.useQueryClient();
+  var connector = client.connector;
+
+  var _useMutation = reactQuery.useMutation(mutationKey$3, chainId => {
+    if (!(connector !== null && connector !== void 0 && connector.switchChain)) throw new core.SwitchChainError();
+    return connector.switchChain(chainId);
+  }, {
+    onError,
+    onMutate,
+    onSettled,
+    onSuccess
+  }),
+      {
+    mutate,
+    mutateAsync,
+    variables: chainId
+  } = _useMutation,
+      networkMutation = _objectWithoutProperties(_useMutation, _excluded$3);
+
+  var queryResult = reactQuery.useQuery(queryKey$3(), queryFn$3);
+  React__namespace.useEffect(() => {
+    var unwatch = core.watchNetwork(data => {
+      queryClient.setQueryData(queryKey$3(), data);
+      forceUpdate();
+    });
+    return unwatch;
+  }, [queryClient]);
+  return _objectSpread2(_objectSpread2({}, networkMutation), {}, {
+    activeChain: (_queryResult$data = queryResult.data) === null || _queryResult$data === void 0 ? void 0 : _queryResult$data.chain,
+    chainId,
+    chains: (_queryResult$data$cha = (_queryResult$data2 = queryResult.data) === null || _queryResult$data2 === void 0 ? void 0 : _queryResult$data2.chains) !== null && _queryResult$data$cha !== void 0 ? _queryResult$data$cha : [],
+    switchNetwork: connector !== null && connector !== void 0 && connector.switchChain ? mutate : undefined,
+    switchNetworkAsync: connector !== null && connector !== void 0 && connector.switchChain ? mutateAsync : undefined
+  });
+}
 
-        return {
-          data: signature,
-          error: undefined
-        };
-      } catch (error_) {
-        var error = error_;
-        if (error_.code === 4001) error = new wagmiCore.UserRejectedRequestError();
-
-        if (!didCancel) {
-          setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
-            error,
-            loading: false
-          }));
-        }
+var queryKey$2 = () => [{
+  entity: 'signer'
+}];
+var queryFn$2 = () => core.fetchSigner();
+function useSigner() {
+  var {
+    onError,
+    onSettled,
+    onSuccess
+  } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var signerQuery = reactQuery.useQuery(queryKey$2(), queryFn$2, {
+    cacheTime: 0,
+    enabled: false,
+    onError,
+    onSettled,
+    onSuccess
+  });
+  var queryClient = reactQuery.useQueryClient();
+  React__namespace.useEffect(() => {
+    var unwatch = core.watchSigner(signer => queryClient.setQueryData(queryKey$2(), signer));
+    return unwatch;
+  }, [queryClient]);
+  var status = !signerQuery.data ? 'loading' : signerQuery.status;
+  return _objectSpread2(_objectSpread2({}, signerQuery), {}, {
+    isIdle: false,
+    isFetching: signerQuery.isFetching || status === 'loading',
+    isLoading: signerQuery.isLoading || status === 'loading',
+    status
+  });
+}
 
-        return {
-          data: undefined,
-          error
-        };
-      }
-    });
+var _excluded$2 = ["mutate", "mutateAsync"];
+var mutationKey$2 = 'signMessage';
 
-    return function (_x) {
-      return _ref.apply(this, arguments);
-    };
-  }(), [cancelQuery, connector, domain, types, value]);
-  return [{
-    data: state.signature,
-    error: state.error,
-    loading: state.loading
-  }, signTypedData];
+var mutationFn$1 = args => {
+  var {
+    message
+  } = args;
+  if (!message) throw new Error('message is required');
+  return core.signMessage({
+    message
+  });
 };
 
-var getContract = _ref => {
+function useSignMessage() {
   var {
-    addressOrName,
-    contractInterface,
-    signerOrProvider
-  } = _ref;
-  return new ethers.Contract(addressOrName, contractInterface, signerOrProvider);
-};
+    message,
+    onError,
+    onMutate,
+    onSettled,
+    onSuccess
+  } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+  var _useMutation = reactQuery.useMutation(mutationKey$2, mutationFn$1, {
+    onError,
+    onMutate,
+    onSettled,
+    onSuccess
+  }),
+      {
+    mutate,
+    mutateAsync
+  } = _useMutation,
+      signMessageMutation = _objectWithoutProperties(_useMutation, _excluded$2);
+
+  var signMessage = React__namespace.useCallback(args => mutate(_objectSpread2({
+    message
+  }, args !== null && args !== void 0 ? args : {})), [message, mutate]);
+  var signMessageAsync = React__namespace.useCallback(args => mutateAsync(_objectSpread2({
+    message
+  }, args !== null && args !== void 0 ? args : {})), [message, mutateAsync]);
+  return _objectSpread2(_objectSpread2({}, signMessageMutation), {}, {
+    signMessage,
+    signMessageAsync
+  });
+}
 
-var useContract = _ref2 => {
+var useContract = _ref => {
   var {
     addressOrName,
     contractInterface,
     signerOrProvider
-  } = _ref2;
+  } = _ref;
   return React__namespace.useMemo(() => {
-    return getContract({
+    return core.getContract({
       addressOrName,
       contractInterface,
       signerOrProvider
@@ -1271,702 +1094,336 @@ var useContractEvent = function useContractEvent(contractConfig, eventName, list
   /* eslint-enable react-hooks/exhaustive-deps */
 };
 
-var initialState$4 = {
-  loading: false
+var queryKey$1 = _ref => {
+  var [contractConfig, functionName, {
+    args,
+    overrides
+  }, {
+    blockNumber,
+    chainId
+  }] = _ref;
+  return [{
+    entity: 'readContract',
+    args,
+    blockNumber,
+    chainId,
+    contractConfig,
+    functionName,
+    overrides
+  }];
+};
+
+var queryFn$1 = _ref2 => {
+  var {
+    queryKey: [{
+      args,
+      contractConfig,
+      functionName,
+      overrides
+    }]
+  } = _ref2;
+  return core.readContract(contractConfig, functionName, {
+    args,
+    overrides
+  });
 };
-var useContractRead = function useContractRead(contractConfig, functionName) {
+
+function useContractRead(contractConfig, functionName) {
   var {
     args,
     overrides,
-    skip,
-    watch
+    watch,
+    cacheTime,
+    enabled: enabled_ = true,
+    keepPreviousData,
+    select,
+    staleTime,
+    suspense,
+    onError,
+    onSettled,
+    onSuccess
   } = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  var cacheBuster = useCacheBuster();
-  var provider = useProvider();
-  var contract = useContract(_objectSpread2({
-    signerOrProvider: provider
-  }, contractConfig));
-  var [{
+  var chainId = useChainId();
+  var {
     data: blockNumber
-  }] = useBlockNumber({
-    skip: true,
+  } = useBlockNumber({
+    enabled: false,
     watch
   });
-  var [state, setState] = React__namespace.useState(initialState$4);
-  var cancelQuery = useCancel();
-  var read = React__namespace.useCallback( /*#__PURE__*/function () {
-    var _ref = _asyncToGenerator(function* (config) {
-      var didCancel = false;
-      cancelQuery(() => {
-        didCancel = true;
-      });
-
-      try {
-        var config_ = config !== null && config !== void 0 ? config : {
-          args,
-          overrides
-        };
-        var params = [...(Array.isArray(config_.args) ? config_.args : config_.args ? [config_.args] : []), ...(config_.overrides ? [config_.overrides] : [])];
-        setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
-          error: undefined,
-          loading: true,
-          response: undefined
-        }));
-        var response = yield contract[functionName](...params);
-
-        if (!didCancel) {
-          setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
-            loading: false,
-            response
-          }));
-        }
-
-        return {
-          data: response,
-          error: undefined
-        };
-      } catch (error_) {
-        var error = error_;
-
-        if (!didCancel) {
-          setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
-            error,
-            loading: false
-          }));
-        }
-
-        return {
-          data: undefined,
-          error
-        };
-      }
-    });
-
-    return function (_x) {
-      return _ref.apply(this, arguments);
-    };
-  }(), [args, cancelQuery, contract, functionName, overrides]);
-  /* eslint-disable react-hooks/exhaustive-deps */
-
-  React__namespace.useEffect(() => {
-    if (skip) return;
-    read();
-    return cancelQuery;
-  }, [cacheBuster, cancelQuery, skip]);
-  /* eslint-enable react-hooks/exhaustive-deps */
-
-  /* eslint-disable react-hooks/exhaustive-deps */
+  var queryKey_ = React__namespace.useMemo(() => queryKey$1([contractConfig, functionName, {
+    args,
+    overrides
+  }, {
+    chainId,
+    blockNumber: watch ? blockNumber : undefined
+  }]), [args, blockNumber, chainId, contractConfig, functionName, overrides, watch]);
+  var enabled = React__namespace.useMemo(() => {
+    var enabled = Boolean(enabled_ && contractConfig && functionName);
+
+    if (watch) {
+      enabled = Boolean(enabled && blockNumber);
+    }
 
+    return enabled;
+  }, [blockNumber, contractConfig, enabled_, functionName, watch]);
+  var client = reactQuery.useQueryClient();
   React__namespace.useEffect(() => {
-    if (!watch) return;
-    if (!blockNumber) return;
-    read();
-    return cancelQuery;
-  }, [blockNumber, cancelQuery, watch]);
-  /* eslint-enable react-hooks/exhaustive-deps */
+    enabled && core.watchReadContract(contractConfig, functionName, {
+      args,
+      overrides,
+      listenToBlock: false
+    }, result => client.setQueryData(queryKey_, result));
+  }, [args, client, contractConfig, enabled, functionName, overrides, queryKey_]);
+  return reactQuery.useQuery(queryKey_, queryFn$1, {
+    cacheTime,
+    enabled,
+    keepPreviousData,
+    select,
+    staleTime,
+    suspense,
+    onError,
+    onSettled,
+    onSuccess
+  });
+}
 
+var _excluded$1 = ["mutate", "mutateAsync"];
+var mutationKey$1 = _ref => {
+  var [contractConfig, functionName, {
+    args,
+    overrides
+  }] = _ref;
   return [{
-    data: state.response,
-    error: state.error,
-    loading: state.loading
-  }, read];
-};
-
-var initialState$3 = {
-  loading: false
+    entity: 'writeContract',
+    args,
+    contractConfig,
+    functionName,
+    overrides
+  }];
 };
-var useContractWrite = function useContractWrite(contractConfig, functionName) {
+function useContractWrite(contractConfig, functionName) {
   var {
     args,
-    overrides
+    overrides,
+    onError,
+    onMutate,
+    onSettled,
+    onSuccess
   } = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  var {
-    state: {
-      connector
-    }
-  } = useContext();
-  var contract = useContract(contractConfig);
-  var [state, setState] = React__namespace.useState(initialState$3);
-  var cancelQuery = useCancel();
-  var write = React__namespace.useCallback( /*#__PURE__*/function () {
-    var _ref = _asyncToGenerator(function* (config) {
-      var didCancel = false;
-      cancelQuery(() => {
-        didCancel = true;
-      });
-
-      try {
-        var config_ = config !== null && config !== void 0 ? config : {
-          args,
-          overrides
-        };
-        if (!connector) throw new wagmiCore.ConnectorNotFoundError();
-        var params = [...(Array.isArray(config_.args) ? config_.args : config_.args ? [config_.args] : []), ...(config_.overrides ? [config_.overrides] : [])];
-        setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
-          error: undefined,
-          loading: true,
-          response: undefined
-        }));
-        var signer = yield connector.getSigner();
-        var contract_ = contract.connect(signer);
-        var response = yield contract_[functionName](...params);
-
-        if (!didCancel) {
-          setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
-            loading: false,
-            response
-          }));
-        }
 
-        return {
-          data: response,
-          error: undefined
-        };
-      } catch (error_) {
-        var error = error_;
-        if (error_.code === 4001) error = new wagmiCore.UserRejectedRequestError();
-
-        if (!didCancel) {
-          setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
-            error,
-            loading: false
-          }));
-        }
-
-        return {
-          data: undefined,
-          error
-        };
-      }
-    });
+  var _useMutation = reactQuery.useMutation(mutationKey$1([contractConfig, functionName, {
+    args,
+    overrides
+  }]), args => core.writeContract(contractConfig, functionName, {
+    args,
+    overrides
+  }), {
+    onError,
+    onMutate,
+    onSettled,
+    onSuccess
+  }),
+      {
+    mutate,
+    mutateAsync
+  } = _useMutation,
+      writeContractMutation = _objectWithoutProperties(_useMutation, _excluded$1);
+
+  var write = React__namespace.useCallback(overrideConfig => mutate(overrideConfig || {
+    args,
+    overrides
+  }), [args, mutate, overrides]);
+  var writeAsync = React__namespace.useCallback(overrideConfig => mutateAsync(overrideConfig || {
+    args,
+    overrides
+  }), [args, mutateAsync, overrides]);
+  return _objectSpread2(_objectSpread2({}, writeContractMutation), {}, {
+    write,
+    writeAsync
+  });
+}
 
-    return function (_x) {
-      return _ref.apply(this, arguments);
-    };
-  }(), [args, cancelQuery, connector, contract, functionName, overrides]);
+var queryKey = _ref => {
+  var {
+    address,
+    chainId,
+    formatUnits
+  } = _ref;
   return [{
-    data: state.response,
-    error: state.error,
-    loading: state.loading
-  }, write];
+    entity: 'token',
+    address,
+    chainId,
+    formatUnits
+  }];
 };
 
-var initialState$2 = {
-  loading: false
+var queryFn = _ref2 => {
+  var {
+    queryKey: [{
+      address,
+      formatUnits
+    }]
+  } = _ref2;
+  if (!address) throw new Error('address is required');
+  return core.fetchToken({
+    address,
+    formatUnits
+  });
 };
-var useToken = function useToken() {
+
+function useToken() {
   var {
     address,
     formatUnits = 'ether',
-    skip
+    cacheTime,
+    enabled = true,
+    keepPreviousData,
+    select,
+    staleTime,
+    suspense,
+    onError,
+    onSettled,
+    onSuccess
   } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-  var {
-    state: {
-      connector
-    }
-  } = useContext();
-  var provider = useProvider();
-  var [state, setState] = React__namespace.useState(initialState$2);
-  var cancelQuery = useCancel();
-  var getToken = React__namespace.useCallback( /*#__PURE__*/function () {
-    var _ref = _asyncToGenerator(function* (config) {
-      var didCancel = false;
-      cancelQuery(() => {
-        didCancel = true;
-      });
-
-      try {
-        var _config_$formatUnits;
-
-        var config_ = config !== null && config !== void 0 ? config : {
-          address,
-          formatUnits
-        };
-        if (!config_.address) throw new Error('address is required');
-        var contract = new ethers.ethers.Contract(config_.address, wagmiCore.erc20ABI, provider);
-        var formatUnits_ = (_config_$formatUnits = config_.formatUnits) !== null && _config_$formatUnits !== void 0 ? _config_$formatUnits : 'ether';
-        setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
-          error: undefined,
-          loading: true
-        }));
-        var [symbol, decimals, totalSupply] = yield Promise.all([contract.symbol(), contract.decimals(), contract.totalSupply()]);
-        var token = {
-          address: config_.address,
-          decimals,
-          symbol,
-          totalSupply: {
-            formatted: ethers.utils.formatUnits(totalSupply, formatUnits_),
-            value: totalSupply
-          }
-        };
-
-        if (!didCancel) {
-          setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
-            token,
-            loading: false
-          }));
-        }
-
-        return {
-          data: token,
-          error: undefined
-        };
-      } catch (error_) {
-        var error = error_;
-
-        if (!didCancel) {
-          setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
-            error,
-            loading: false
-          }));
-        }
-
-        return {
-          data: undefined,
-          error
-        };
-      }
-    });
-
-    return function (_x) {
-      return _ref.apply(this, arguments);
-    };
-  }(), [address, cancelQuery, formatUnits, provider]);
-  var watchToken = React__namespace.useCallback( /*#__PURE__*/function () {
-    var _ref2 = _asyncToGenerator(function* (token) {
-      if (!(connector !== null && connector !== void 0 && connector.watchAsset)) return false;
-
-      try {
-        yield connector.watchAsset(token);
-        return true;
-      } catch (error) {
-        return error;
-      }
-    });
-
-    return function (_x2) {
-      return _ref2.apply(this, arguments);
-    };
-  }(), [connector]);
-  /* eslint-disable react-hooks/exhaustive-deps */
-
-  React__namespace.useEffect(() => {
-    if (skip || !address) return;
-    getToken({
-      address,
-      formatUnits
-    });
-    return cancelQuery;
-  }, [address, cancelQuery, formatUnits, skip]);
-  /* eslint-enable react-hooks/exhaustive-deps */
+  var chainId = useChainId();
+  return reactQuery.useQuery(queryKey({
+    address,
+    chainId,
+    formatUnits
+  }), queryFn, {
+    cacheTime,
+    enabled: Boolean(enabled && address),
+    keepPreviousData,
+    select,
+    staleTime,
+    suspense,
+    onError,
+    onSettled,
+    onSuccess
+  });
+}
 
+var _excluded = ["mutate", "mutateAsync"];
+var mutationKey = _ref => {
+  var {
+    request
+  } = _ref;
   return [{
-    data: state.token ? _objectSpread2(_objectSpread2({}, state.token), {}, {
-      address
-    }) : undefined,
-    error: state.error,
-    loading: state.loading
-  }, watchToken, getToken];
+    entity: 'writeContract',
+    request
+  }];
 };
 
-var initialState$1 = {
-  loading: false
-};
-var useTransaction = function useTransaction() {
+var mutationFn = args => {
   var {
     request
-  } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-  var {
-    state: {
-      connector
-    }
-  } = useContext();
-  var [state, setState] = React__namespace.useState(initialState$1);
-  var cancelQuery = useCancel();
-  var sendTransaction = React__namespace.useCallback( /*#__PURE__*/function () {
-    var _ref = _asyncToGenerator(function* (config) {
-      var didCancel = false;
-      cancelQuery(() => {
-        didCancel = true;
-      });
-
-      try {
-        var config_ = config !== null && config !== void 0 ? config : {
-          request
-        };
-        if (!config_.request) throw new Error('request is required');
-        if (!connector) throw new wagmiCore.ConnectorNotFoundError();
-        setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
-          loading: true
-        }));
-        var signer = yield connector.getSigner();
-        var transaction = yield signer.sendTransaction(config_.request);
-
-        if (!didCancel) {
-          setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
-            loading: false,
-            transaction
-          }));
-        }
-
-        return {
-          data: transaction,
-          error: undefined
-        };
-      } catch (error_) {
-        var error = error_;
-        if (error_.code === 4001) error = new wagmiCore.UserRejectedRequestError();
-
-        if (!didCancel) {
-          setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
-            error,
-            loading: false
-          }));
-        }
-
-        return {
-          data: undefined,
-          error
-        };
-      }
-    });
-
-    return function (_x) {
-      return _ref.apply(this, arguments);
-    };
-  }(), [cancelQuery, connector, request]);
-  return [{
-    data: state.transaction,
-    error: state.error,
-    loading: state.loading
-  }, sendTransaction];
+  } = args;
+  if (!request) throw new Error('request is required');
+  return core.sendTransaction({
+    request
+  });
 };
 
-var initialState = {
-  loading: false
-};
-var useWaitForTransaction = function useWaitForTransaction() {
+function useSendTransaction() {
   var {
-    confirmations,
-    hash,
-    skip,
-    timeout,
-    wait: wait_
+    request,
+    onError,
+    onMutate,
+    onSettled,
+    onSuccess
   } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-  var provider = useProvider();
-  var [state, setState] = React__namespace.useState(initialState);
-  var cancelQuery = useCancel();
-  var wait = React__namespace.useCallback( /*#__PURE__*/function () {
-    var _ref = _asyncToGenerator(function* (config) {
-      var didCancel = false;
-      cancelQuery(() => {
-        didCancel = true;
-      });
-
-      try {
-        var config_ = config !== null && config !== void 0 ? config : {
-          confirmations,
-          hash,
-          timeout,
-          wait: wait_
-        };
-        if (!config_.hash && !config_.wait) throw new Error('hash or wait is required');
-        var promise; // eslint-disable-next-line testing-library/await-async-utils
-
-        if (config_.wait) promise = config_.wait(config_.confirmations);else if (config_.hash) promise = provider.waitForTransaction(config_.hash, config_.confirmations, config_.timeout);else throw new Error('hash or wait is required');
-        setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
-          loading: true
-        }));
-        var receipt = yield promise;
-
-        if (!didCancel) {
-          setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
-            loading: false,
-            receipt
-          }));
-        }
-
-        return {
-          data: receipt,
-          error: undefined
-        };
-      } catch (error_) {
-        var error = error_;
-
-        if (!didCancel) {
-          setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
-            error,
-            loading: false
-          }));
-        }
-
-        return {
-          data: undefined,
-          error
-        };
-      }
-    });
-
-    return function (_x) {
-      return _ref.apply(this, arguments);
-    };
-  }(), [cancelQuery, confirmations, hash, provider, timeout, wait_]); // Fetch balance when deps or chain changes
-
-  /* eslint-disable react-hooks/exhaustive-deps */
-
-  React__namespace.useEffect(() => {
-    if (skip || !hash && !wait_) return;
-    /* eslint-disable testing-library/await-async-utils */
-
-    wait({
-      confirmations,
-      hash,
-      timeout,
-      wait: wait_
-    });
-    /* eslint-enable testing-library/await-async-utils */
-
-    return cancelQuery;
-  }, [cancelQuery, hash, skip, wait_]);
-  /* eslint-enable react-hooks/exhaustive-deps */
-
-  return [{
-    data: state.receipt,
-    error: state.error,
-    loading: state.loading
-  }, wait];
-};
-
-var Context = /*#__PURE__*/React__namespace.createContext(null);
-var Provider = _ref => {
-  var _state$data2, _state$data2$chain, _state$data4, _state$data4$chain, _state$data6, _state$data6$chain;
 
-  var {
-    autoConnect = false,
-    children,
-    connectors: connectors_ = [new wagmiCore.InjectedConnector()],
-    connectorStorageKey = 'wagmi.wallet',
-    provider: provider_ = providers.getDefaultProvider(),
-    webSocketProvider: webSocketProvider_
-  } = _ref;
-  var [lastUsedConnector, setLastUsedConnector] = useLocalStorage(connectorStorageKey);
-  var [state, setState] = React__namespace.useState({
-    cacheBuster: 1,
-    connecting: autoConnect
+  var _useMutation = reactQuery.useMutation(mutationKey({
+    request
+  }), mutationFn, {
+    onError,
+    onMutate,
+    onSettled,
+    onSuccess
+  }),
+      {
+    mutate,
+    mutateAsync
+  } = _useMutation,
+      transactionMutation = _objectWithoutProperties(_useMutation, _excluded);
+
+  var sendTransaction = React__namespace.useCallback(args => mutate(_objectSpread2({
+    request
+  }, args !== null && args !== void 0 ? args : {})), [mutate, request]);
+  var sendTransactionAsync = React__namespace.useCallback(args => mutateAsync(_objectSpread2({
+    request
+  }, args !== null && args !== void 0 ? args : {})), [mutateAsync, request]);
+  return _objectSpread2(_objectSpread2({}, transactionMutation), {}, {
+    sendTransaction,
+    sendTransactionAsync
   });
-  var connectors = React__namespace.useMemo(() => {
-    var _state$data, _state$data$chain;
-
-    if (typeof connectors_ !== 'function') return connectors_;
-    return connectors_({
-      chainId: (_state$data = state.data) === null || _state$data === void 0 ? void 0 : (_state$data$chain = _state$data.chain) === null || _state$data$chain === void 0 ? void 0 : _state$data$chain.id
-    });
-  }, [connectors_, (_state$data2 = state.data) === null || _state$data2 === void 0 ? void 0 : (_state$data2$chain = _state$data2.chain) === null || _state$data2$chain === void 0 ? void 0 : _state$data2$chain.id]);
-  var provider = React__namespace.useMemo(() => {
-    var _state$data3, _state$data3$chain;
-
-    if (typeof provider_ !== 'function') return provider_;
-    return provider_({
-      chainId: (_state$data3 = state.data) === null || _state$data3 === void 0 ? void 0 : (_state$data3$chain = _state$data3.chain) === null || _state$data3$chain === void 0 ? void 0 : _state$data3$chain.id,
-      connector: state.connector
-    });
-  }, [provider_, (_state$data4 = state.data) === null || _state$data4 === void 0 ? void 0 : (_state$data4$chain = _state$data4.chain) === null || _state$data4$chain === void 0 ? void 0 : _state$data4$chain.id, state.connector]);
-  var webSocketProvider = React__namespace.useMemo(() => {
-    var _state$data5, _state$data5$chain;
-
-    if (!webSocketProvider_) return undefined;
-    if (typeof webSocketProvider_ !== 'function') return webSocketProvider_;
-    return webSocketProvider_({
-      chainId: (_state$data5 = state.data) === null || _state$data5 === void 0 ? void 0 : (_state$data5$chain = _state$data5.chain) === null || _state$data5$chain === void 0 ? void 0 : _state$data5$chain.id,
-      connector: state.connector
-    });
-  }, [webSocketProvider_, (_state$data6 = state.data) === null || _state$data6 === void 0 ? void 0 : (_state$data6$chain = _state$data6.chain) === null || _state$data6$chain === void 0 ? void 0 : _state$data6$chain.id, state.connector]); // Attempt to connect on mount
-
-  /* eslint-disable react-hooks/exhaustive-deps */
-
-  React__namespace.useEffect(() => {
-    if (!autoConnect) return;
-
-    _asyncToGenerator(function* () {
-      setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
-        connecting: true
-      }));
-      var sorted = lastUsedConnector ? [...connectors].sort(x => x.name === lastUsedConnector ? -1 : 1) : connectors;
-
-      var _loop = function* _loop(connector) {
-        if (!connector.ready || !connector.isAuthorized) return "continue";
-        var isAuthorized = yield connector.isAuthorized();
-        if (!isAuthorized) return "continue";
-        var data = yield connector.connect();
-        setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
-          connector,
-          data
-        }));
-        return "break";
-      };
-
-      for (var connector of sorted) {
-        var _ret = yield* _loop(connector);
-
-        if (_ret === "continue") continue;
-        if (_ret === "break") break;
-      }
-
-      setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
-        connecting: false
-      }));
-    })();
-  }, []);
-  /* eslint-enable react-hooks/exhaustive-deps */
-  // Make sure connectors close
-
-  React__namespace.useEffect(() => {
-    return () => {
-      if (!state.connector) return;
-      state.connector.disconnect();
-    };
-  }, [state.connector]); // Watch connector for events
-
-  React__namespace.useEffect(() => {
-    if (!state.connector) return;
-
-    var onChange = data => setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
-      cacheBuster: x.cacheBuster + 1,
-      data: _objectSpread2(_objectSpread2({}, x.data), data)
-    }));
-
-    var onDisconnect = () => setState({
-      cacheBuster: 1
-    });
-
-    var onError = error => setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
-      error
-    }));
-
-    state.connector.on('change', onChange);
-    state.connector.on('disconnect', onDisconnect);
-    state.connector.on('error', onError);
-    return () => {
-      if (!state.connector) return;
-      state.connector.off('change', onChange);
-      state.connector.off('disconnect', onDisconnect);
-      state.connector.off('error', onError);
-    };
-  }, [state.connector]);
-  var value = {
-    state: {
-      cacheBuster: state.cacheBuster,
-      connecting: state.connecting,
-      connectors,
-      connector: state.connector,
-      data: state.data,
-      provider,
-      webSocketProvider
-    },
-    setState,
-    setLastUsedConnector
-  };
-  return /*#__PURE__*/React__namespace.createElement(Context.Provider, {
-    value
-  }, children);
-};
-var useContext = () => {
-  var context = React__namespace.useContext(Context);
-  if (!context) throw Error('Must be used within Provider');
-  return context;
-};
+}
 
-Object.defineProperty(exports, 'AddChainError', {
-  enumerable: true,
-  get: function () { return wagmiCore.AddChainError; }
-});
-Object.defineProperty(exports, 'ChainNotConfiguredError', {
+Object.defineProperty(exports, 'Client', {
   enumerable: true,
-  get: function () { return wagmiCore.ChainNotConfiguredError; }
+  get: function () { return core.Client; }
 });
 Object.defineProperty(exports, 'Connector', {
   enumerable: true,
-  get: function () { return wagmiCore.Connector; }
-});
-Object.defineProperty(exports, 'ConnectorAlreadyConnectedError', {
-  enumerable: true,
-  get: function () { return wagmiCore.ConnectorAlreadyConnectedError; }
-});
-Object.defineProperty(exports, 'ConnectorNotFoundError', {
-  enumerable: true,
-  get: function () { return wagmiCore.ConnectorNotFoundError; }
+  get: function () { return core.Connector; }
 });
-Object.defineProperty(exports, 'InjectedConnector', {
+Object.defineProperty(exports, 'WagmiClient', {
   enumerable: true,
-  get: function () { return wagmiCore.InjectedConnector; }
-});
-Object.defineProperty(exports, 'SwitchChainError', {
-  enumerable: true,
-  get: function () { return wagmiCore.SwitchChainError; }
-});
-Object.defineProperty(exports, 'UserRejectedRequestError', {
-  enumerable: true,
-  get: function () { return wagmiCore.UserRejectedRequestError; }
+  get: function () { return core.WagmiClient; }
 });
 Object.defineProperty(exports, 'allChains', {
   enumerable: true,
-  get: function () { return wagmiCore.allChains; }
+  get: function () { return core.allChains; }
 });
 Object.defineProperty(exports, 'chain', {
   enumerable: true,
-  get: function () { return wagmiCore.chain; }
+  get: function () { return core.chain; }
 });
-Object.defineProperty(exports, 'defaultChains', {
+Object.defineProperty(exports, 'createStorage', {
   enumerable: true,
-  get: function () { return wagmiCore.defaultChains; }
+  get: function () { return core.createStorage; }
 });
-Object.defineProperty(exports, 'defaultL2Chains', {
+Object.defineProperty(exports, 'createWagmiStorage', {
   enumerable: true,
-  get: function () { return wagmiCore.defaultL2Chains; }
+  get: function () { return core.createWagmiStorage; }
 });
-Object.defineProperty(exports, 'developmentChains', {
+Object.defineProperty(exports, 'defaultChains', {
   enumerable: true,
-  get: function () { return wagmiCore.developmentChains; }
+  get: function () { return core.defaultChains; }
 });
 Object.defineProperty(exports, 'erc1155ABI', {
   enumerable: true,
-  get: function () { return wagmiCore.erc1155ABI; }
+  get: function () { return core.erc1155ABI; }
 });
 Object.defineProperty(exports, 'erc20ABI', {
   enumerable: true,
-  get: function () { return wagmiCore.erc20ABI; }
+  get: function () { return core.erc20ABI; }
 });
 Object.defineProperty(exports, 'erc721ABI', {
   enumerable: true,
-  get: function () { return wagmiCore.erc721ABI; }
-});
-Object.defineProperty(exports, 'normalizeChainId', {
-  enumerable: true,
-  get: function () { return wagmiCore.normalizeChainId; }
+  get: function () { return core.erc721ABI; }
 });
-exports.Context = Context;
 exports.Provider = Provider;
 exports.WagmiProvider = Provider;
+exports.createClient = createClient;
 exports.useAccount = useAccount;
 exports.useBalance = useBalance;
 exports.useBlockNumber = useBlockNumber;
+exports.useClient = useClient;
 exports.useConnect = useConnect;
-exports.useContext = useContext;
 exports.useContract = useContract;
 exports.useContractEvent = useContractEvent;
 exports.useContractRead = useContractRead;
 exports.useContractWrite = useContractWrite;
+exports.useEnsAddress = useEnsAddress;
 exports.useEnsAvatar = useEnsAvatar;
-exports.useEnsLookup = useEnsLookup;
-exports.useEnsResolveName = useEnsResolveName;
+exports.useEnsName = useEnsName;
 exports.useEnsResolver = useEnsResolver;
-exports.useFeeData = useFeeData;
 exports.useNetwork = useNetwork;
 exports.useProvider = useProvider;
+exports.useSendTransaction = useSendTransaction;
 exports.useSignMessage = useSignMessage;
-exports.useSignTypedData = useSignTypedData;
 exports.useSigner = useSigner;
 exports.useToken = useToken;
-exports.useTransaction = useTransaction;
-exports.useWaitForTransaction = useWaitForTransaction;
+exports.useWagmiClient = useClient;
 exports.useWebSocketProvider = useWebSocketProvider;