wagmi 0.2.21 → 0.2.24

package/dist/wagmi.cjs.dev.js

@@ -27,104 +27,27 @@ function _interopNamespace(e) {
 
 var React__namespace = /*#__PURE__*/_interopNamespace(React);
 
-function _defineProperty(obj, key, value) {
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value: value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  } else {
-    obj[key] = value;
-  }
-
-  return obj;
-}
-
-function ownKeys(object, enumerableOnly) {
-  var keys = Object.keys(object);
-
-  if (Object.getOwnPropertySymbols) {
-    var symbols = Object.getOwnPropertySymbols(object);
-    enumerableOnly && (symbols = symbols.filter(function (sym) {
-      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
-    })), keys.push.apply(keys, symbols);
-  }
-
-  return keys;
-}
-
-function _objectSpread2(target) {
-  for (var i = 1; i < arguments.length; i++) {
-    var source = null != arguments[i] ? arguments[i] : {};
-    i % 2 ? ownKeys(Object(source), !0).forEach(function (key) {
-      _defineProperty(target, key, source[key]);
-    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) {
-      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
-    });
-  }
-
-  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;
-  }
-
-  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);
-    });
-  };
-}
-
-var useProvider = () => {
-  var {
+const useProvider = () => {
+  const {
     state
   } = useContext();
   return state.provider;
 };
 
-var useWebSocketProvider = () => {
-  var {
+const useWebSocketProvider = () => {
+  const {
     state
   } = useContext();
   return state.webSocketProvider;
 };
 
-var useCacheBuster = () => {
-  var context = useContext();
+const useCacheBuster = () => {
+  const context = useContext();
   return context.state.cacheBuster;
 };
 
-var useCancel = () => {
-  var cancelCallback = React__namespace.useRef(null);
+const useCancel = () => {
+  const cancelCallback = React__namespace.useRef(null);
   React__namespace.useEffect(() => {
     return () => {
       var _cancelCallback$curre;
@@ -132,7 +55,7 @@ var useCancel = () => {
       return (_cancelCallback$curre = cancelCallback.current) === null || _cancelCallback$curre === void 0 ? void 0 : _cancelCallback$curre.call(cancelCallback);
     };
   }, []);
-  var cancel = React__namespace.useCallback(callback => {
+  const cancel = React__namespace.useCallback(callback => {
     var _cancelCallback$curre2;
 
     (_cancelCallback$curre2 = cancelCallback.current) === null || _cancelCallback$curre2 === void 0 ? void 0 : _cancelCallback$curre2.call(cancelCallback);
@@ -141,11 +64,11 @@ var useCancel = () => {
   return cancel;
 };
 
-var useLocalStorage = function useLocalStorage(key) {
-  var defaultState = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
-  var [value, setValue] = React__namespace.useState(() => {
+const useLocalStorage = function (key) {
+  let defaultState = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+  const [value, setValue] = React__namespace.useState(() => {
     if (typeof localStorage === 'undefined') return defaultState;
-    var value = localStorage.getItem(key);
+    const value = localStorage.getItem(key);
 
     try {
       return value ? JSON.parse(value) : defaultState;
@@ -154,7 +77,7 @@ var useLocalStorage = function useLocalStorage(key) {
       return defaultState;
     }
   });
-  var setLocalStorage = React__namespace.useCallback(newValue => {
+  const setLocalStorage = React__namespace.useCallback(newValue => {
     if (newValue === value) return;
     setValue(newValue);
     if (newValue === null) localStorage.removeItem(key);else localStorage.setItem(key, JSON.stringify(newValue));
@@ -172,62 +95,56 @@ var useLocalStorage = function useLocalStorage(key) {
   return [value, setLocalStorage];
 };
 
-var initialState$g = {
+const initialState$g = {
   loading: false
 };
-var useEnsAvatar = function useEnsAvatar() {
-  var {
+const useEnsAvatar = function () {
+  let {
     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);
+  const cacheBuster = useCacheBuster();
+  const provider = useProvider();
+  const [state, setState] = React__namespace.useState(initialState$g);
+  const cancelQuery = useCancel();
+  const getEnsAvatar = React__namespace.useCallback(async config => {
+    let didCancel = false;
+    cancelQuery(() => {
+      didCancel = true;
+    });
 
-        if (!didCancel) {
-          setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
-            avatar,
-            loading: false
-          }));
-        }
+    try {
+      const config_ = config !== null && config !== void 0 ? config : {
+        addressOrName
+      };
+      if (!config_.addressOrName) throw new Error('addressOrName is required');
+      setState(x => ({ ...x,
+        error: undefined,
+        loading: true
+      }));
+      const avatar = await provider.getAvatar(config_.addressOrName);
 
-        return avatar;
-      } catch (error_) {
-        var error = error_;
+      if (!didCancel) {
+        setState(x => ({ ...x,
+          avatar,
+          loading: false
+        }));
+      }
 
-        if (!didCancel) {
-          setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
-            error,
-            loading: false
-          }));
-        }
+      return avatar;
+    } catch (error_) {
+      const error = error_;
 
-        return error;
+      if (!didCancel) {
+        setState(x => ({ ...x,
+          error,
+          loading: false
+        }));
       }
-    });
 
-    return function (_x) {
-      return _ref.apply(this, arguments);
-    };
-  }(), [addressOrName, cancelQuery, provider]); // Fetch avatar when deps or chain changes
+      return error;
+    }
+  }, [addressOrName, cancelQuery, provider]); // Fetch avatar when deps or chain changes
 
   /* eslint-disable react-hooks/exhaustive-deps */
 
@@ -247,68 +164,62 @@ var useEnsAvatar = function useEnsAvatar() {
   }, getEnsAvatar];
 };
 
-var initialState$f = {
+const initialState$f = {
   loading: false
 };
-var useEnsLookup = function useEnsLookup() {
-  var {
+const useEnsLookup = function () {
+  let {
     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;
-      });
+  const cacheBuster = useCacheBuster();
+  const provider = useProvider();
+  const [state, setState] = React__namespace.useState(initialState$f);
+  const cancelQuery = useCancel();
+  const lookupAddress = React__namespace.useCallback(async config => {
+    let 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);
+    try {
+      const config_ = config !== null && config !== void 0 ? config : {
+        address
+      };
+      if (!config_.address) throw new Error('address is required');
+      setState(x => ({ ...x,
+        error: undefined,
+        loading: true
+      }));
+      const ens = await provider.lookupAddress(config_.address);
 
-        if (!didCancel) {
-          setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
-            ens,
-            loading: false
-          }));
-        }
+      if (!didCancel) {
+        setState(x => ({ ...x,
+          ens,
+          loading: false
+        }));
+      }
 
-        return {
-          data: ens,
-          error: undefined
-        };
-      } catch (error_) {
-        var error = error_;
-
-        if (!didCancel) {
-          setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
-            error,
-            loading: false
-          }));
-        }
+      return {
+        data: ens,
+        error: undefined
+      };
+    } catch (error_) {
+      const error = error_;
 
-        return {
-          data: undefined,
-          error
-        };
+      if (!didCancel) {
+        setState(x => ({ ...x,
+          error,
+          loading: false
+        }));
       }
-    });
 
-    return function (_x) {
-      return _ref.apply(this, arguments);
-    };
-  }(), [address, cancelQuery, provider]); // Resolve name when deps or chain changes
+      return {
+        data: undefined,
+        error
+      };
+    }
+  }, [address, cancelQuery, provider]); // Resolve name when deps or chain changes
 
   /* eslint-disable react-hooks/exhaustive-deps */
 
@@ -328,68 +239,62 @@ var useEnsLookup = function useEnsLookup() {
   }, lookupAddress];
 };
 
-var initialState$e = {
+const initialState$e = {
   loading: false
 };
-var useEnsResolveName = function useEnsResolveName() {
-  var {
+const useEnsResolveName = function () {
+  let {
     name,
     skip
   } = 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;
-      });
+  const cacheBuster = useCacheBuster();
+  const provider = useProvider();
+  const [state, setState] = React__namespace.useState(initialState$e);
+  const cancelQuery = useCancel();
+  const resolveName = React__namespace.useCallback(async config => {
+    let 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 address = yield provider.resolveName(config_.name);
+    try {
+      const config_ = config !== null && config !== void 0 ? config : {
+        name
+      };
+      if (!config_.name) throw new Error('name is required');
+      setState(x => ({ ...x,
+        error: undefined,
+        loading: true
+      }));
+      const address = await provider.resolveName(config_.name);
 
-        if (!didCancel) {
-          setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
-            address,
-            loading: false
-          }));
-        }
+      if (!didCancel) {
+        setState(x => ({ ...x,
+          address,
+          loading: false
+        }));
+      }
 
-        return {
-          data: address,
-          error: undefined
-        };
-      } catch (error_) {
-        var error = error_;
-
-        if (!didCancel) {
-          setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
-            error,
-            loading: false
-          }));
-        }
+      return {
+        data: address,
+        error: undefined
+      };
+    } catch (error_) {
+      const error = error_;
 
-        return {
-          data: undefined,
-          error
-        };
+      if (!didCancel) {
+        setState(x => ({ ...x,
+          error,
+          loading: false
+        }));
       }
-    });
 
-    return function (_x) {
-      return _ref.apply(this, arguments);
-    };
-  }(), [name, cancelQuery, provider]); // Resolve name when deps or chain changes
+      return {
+        data: undefined,
+        error
+      };
+    }
+  }, [name, cancelQuery, provider]); // Resolve name when deps or chain changes
 
   /* eslint-disable react-hooks/exhaustive-deps */
 
@@ -409,68 +314,62 @@ var useEnsResolveName = function useEnsResolveName() {
   }, resolveName];
 };
 
-var initialState$d = {
+const initialState$d = {
   loading: false
 };
-var useEnsResolver = function useEnsResolver() {
-  var {
+const useEnsResolver = function () {
+  let {
     name,
     skip
   } = 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;
-      });
+  const cacheBuster = useCacheBuster();
+  const provider = useProvider();
+  const [state, setState] = React__namespace.useState(initialState$d);
+  const cancelQuery = useCancel();
+  const getEnsResolver = React__namespace.useCallback(async config => {
+    let 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);
+    try {
+      const config_ = config !== null && config !== void 0 ? config : {
+        name
+      };
+      if (!config_.name) throw new Error('name is required');
+      setState(x => ({ ...x,
+        error: undefined,
+        loading: true
+      }));
+      const resolver = await provider.getResolver(config_.name);
 
-        if (!didCancel) {
-          setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
-            loading: false,
-            resolver
-          }));
-        }
+      if (!didCancel) {
+        setState(x => ({ ...x,
+          loading: false,
+          resolver
+        }));
+      }
 
-        return {
-          data: resolver,
-          error: undefined
-        };
-      } catch (error_) {
-        var error = error_;
-
-        if (!didCancel) {
-          setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
-            error,
-            loading: false
-          }));
-        }
+      return {
+        data: resolver,
+        error: undefined
+      };
+    } catch (error_) {
+      const error = error_;
 
-        return {
-          data: undefined,
-          error
-        };
+      if (!didCancel) {
+        setState(x => ({ ...x,
+          error,
+          loading: false
+        }));
       }
-    });
 
-    return function (_x) {
-      return _ref.apply(this, arguments);
-    };
-  }(), [cancelQuery, name, provider]); // Fetch avatar when deps or chain changes
+      return {
+        data: undefined,
+        error
+      };
+    }
+  }, [cancelQuery, name, provider]); // Fetch avatar when deps or chain changes
 
   /* eslint-disable react-hooks/exhaustive-deps */
 
@@ -490,18 +389,18 @@ var useEnsResolver = function useEnsResolver() {
   }, getEnsResolver];
 };
 
-var useAccount = function useAccount() {
+const useAccount = function () {
   var _globalState$data;
 
-  var {
+  let {
     fetchEns
   } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-  var {
+  const {
     state: globalState,
     setState
   } = useContext();
-  var address = (_globalState$data = globalState.data) === null || _globalState$data === void 0 ? void 0 : _globalState$data.account;
-  var [{
+  const address = (_globalState$data = globalState.data) === null || _globalState$data === void 0 ? void 0 : _globalState$data.account;
+  const [{
     data: ens,
     error: ensError,
     loading: ensLoading
@@ -509,7 +408,7 @@ var useAccount = function useAccount() {
     address,
     skip: !fetchEns
   });
-  var [{
+  const [{
     data: avatar,
     error: avatarError,
     loading: avatarLoading
@@ -517,7 +416,7 @@ var useAccount = function useAccount() {
     addressOrName: ens,
     skip: !fetchEns || !ens
   });
-  var disconnect = React__namespace.useCallback(() => {
+  const disconnect = React__namespace.useCallback(() => {
     setState(x => {
       var _x$connector;
 
@@ -527,8 +426,8 @@ var useAccount = function useAccount() {
       };
     });
   }, [setState]);
-  var error = ensError || avatarError;
-  var loading = ensLoading || avatarLoading;
+  const error = ensError || avatarError;
+  const loading = ensLoading || avatarLoading;
   return [{
     data: address ? {
       address,
@@ -543,34 +442,34 @@ var useAccount = function useAccount() {
   }, disconnect];
 };
 
-var initialState$c = {
+const initialState$c = {
   loading: false
 };
-var useBlockNumber = function useBlockNumber() {
-  var {
+const useBlockNumber = function () {
+  let {
     skip,
     watch
   } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-  var cacheBuster = useCacheBuster();
-  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;
+  const cacheBuster = useCacheBuster();
+  const provider = useProvider();
+  const webSocketProvider = useWebSocketProvider();
+  const [state, setState] = React__namespace.useState(initialState$c);
+  const cancelQuery = useCancel();
+  const getBlockNumber = React__namespace.useCallback(async () => {
+    let didCancel = false;
     cancelQuery(() => {
       didCancel = true;
     });
 
     try {
-      setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
+      setState(x => ({ ...x,
         error: undefined,
         loading: true
       }));
-      var blockNumber = yield provider.getBlockNumber();
+      const blockNumber = await provider.getBlockNumber();
 
       if (!didCancel) {
-        setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
+        setState(x => ({ ...x,
           blockNumber,
           loading: false
         }));
@@ -581,10 +480,10 @@ var useBlockNumber = function useBlockNumber() {
         error: undefined
       };
     } catch (error_) {
-      var error = error_;
+      const error = error_;
 
       if (!didCancel) {
-        setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
+        setState(x => ({ ...x,
           error,
           loading: false
         }));
@@ -595,7 +494,7 @@ var useBlockNumber = function useBlockNumber() {
         error
       };
     }
-  }), [cancelQuery, provider]);
+  }, [cancelQuery, provider]);
   /* eslint-disable react-hooks/exhaustive-deps */
 
   React__namespace.useEffect(() => {
@@ -607,19 +506,19 @@ var useBlockNumber = function useBlockNumber() {
 
   React__namespace.useEffect(() => {
     if (!watch) return;
-    var didCancel = false;
+    let didCancel = false;
 
-    var listener = blockNumber => {
+    const 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), {}, {
+        setState(x => ({ ...x,
           blockNumber
         }));
       }
     };
 
-    var provider_ = webSocketProvider !== null && webSocketProvider !== void 0 ? webSocketProvider : provider;
+    const provider_ = webSocketProvider !== null && webSocketProvider !== void 0 ? webSocketProvider : provider;
     provider_.on('block', listener);
     return () => {
       didCancel = true;
@@ -633,40 +532,40 @@ var useBlockNumber = function useBlockNumber() {
   }, getBlockNumber];
 };
 
-var initialState$b = {
+const initialState$b = {
   loading: false
 };
-var useFeeData = function useFeeData() {
-  var {
+const useFeeData = function () {
+  let {
     formatUnits = 'wei',
     skip,
     watch
   } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-  var provider = useProvider();
-  var [{
+  const provider = useProvider();
+  const [{
     data: blockNumber
   }] = useBlockNumber({
     skip: true,
     watch
   });
-  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;
+  const cacheBuster = useCacheBuster();
+  const [state, setState] = React__namespace.useState(initialState$b);
+  const cancelQuery = useCancel();
+  const getFeeData = React__namespace.useCallback(async () => {
+    let didCancel = false;
     cancelQuery(() => {
       didCancel = true;
     });
 
     try {
-      setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
+      setState(x => ({ ...x,
         error: undefined,
         loading: true
       }));
-      var feeData = yield provider.getFeeData();
+      const feeData = await provider.getFeeData();
 
       if (!didCancel) {
-        setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
+        setState(x => ({ ...x,
           feeData,
           loading: false
         }));
@@ -677,10 +576,10 @@ var useFeeData = function useFeeData() {
         error: undefined
       };
     } catch (error_) {
-      var error = error_;
+      const error = error_;
 
       if (!didCancel) {
-        setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
+        setState(x => ({ ...x,
           error,
           loading: false
         }));
@@ -691,7 +590,7 @@ var useFeeData = function useFeeData() {
         error
       };
     }
-  }), [cancelQuery, provider]); // Fetch feeData on mount or when chain changes
+  }, [cancelQuery, provider]); // Fetch feeData on mount or when chain changes
 
   /* eslint-disable react-hooks/exhaustive-deps */
 
@@ -707,96 +606,90 @@ var useFeeData = function useFeeData() {
     getFeeData();
     return cancelQuery;
   }, [blockNumber, cancelQuery, getFeeData, watch]);
-  var formatted = state.feeData ? {
+  const 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), {}, {
+    data: state.feeData ? { ...state.feeData,
       formatted
-    }) : undefined,
+    } : undefined,
     loading: state.loading,
     error: state.error
   }, getFeeData];
 };
 
-var initialState$a = {
+const initialState$a = {
   loading: false
 };
-var useBalance = function useBalance() {
-  var {
+const useBalance = function () {
+  let {
     addressOrName,
     formatUnits = 'ether',
     skip,
     token,
     watch
   } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-  var {
+  const {
     state: {
       connector
     }
   } = useContext();
-  var cacheBuster = useCacheBuster();
-  var provider = useProvider();
-  var [{
+  const cacheBuster = useCacheBuster();
+  const provider = useProvider();
+  const [{
     data: blockNumber
   }] = useBlockNumber({
     skip: true,
     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
-        };
-      }
+  const [state, setState] = React__namespace.useState(initialState$a);
+  const cancelQuery = useCancel();
+  const getBalance = React__namespace.useCallback(async config => {
+    let didCancel = false;
+    cancelQuery(() => {
+      didCancel = true;
     });
 
-    return function (_x) {
-      return _ref.apply(this, arguments);
-    };
-  }(), [addressOrName, cancelQuery, connector, formatUnits, provider, token]); // Fetch balance when deps or chain changes
+    try {
+      var _connector$chains;
+
+      const config_ = config !== null && config !== void 0 ? config : {
+        addressOrName,
+        formatUnits,
+        token
+      };
+      if (!config_.addressOrName) throw new Error('address is required');
+      setState(x => ({ ...x,
+        error: undefined,
+        loading: true
+      }));
+      const balance = await 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 => ({ ...x,
+        balance,
+        loading: false
+      }));
+      return {
+        data: balance,
+        error: undefined
+      };
+    } catch (error_) {
+      const error = error_;
+      if (!didCancel) setState(x => ({ ...x,
+        error,
+        loading: false
+      }));
+      return {
+        data: undefined,
+        error
+      };
+    }
+  }, [addressOrName, cancelQuery, connector, formatUnits, provider, token]); // Fetch balance when deps or chain changes
 
   /* eslint-disable react-hooks/exhaustive-deps */
 
@@ -832,77 +725,71 @@ var useBalance = function useBalance() {
   }, getBalance];
 };
 
-var initialState$9 = {
+const initialState$9 = {
   loading: false
 };
-var useConnect = () => {
+const useConnect = () => {
   var _globalState$data;
 
-  var {
+  const {
     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;
-      });
+  const [state, setState] = React__namespace.useState(initialState$9);
+  const cancelQuery = useCancel();
+  const connect = React__namespace.useCallback(async connector => {
+    let 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,
+    try {
+      const activeConnector = globalState === null || globalState === void 0 ? void 0 : globalState.connector;
+      if (connector === activeConnector) throw new wagmiCore.ConnectorAlreadyConnectedError();
+      setState(x => ({ ...x,
+        loading: true,
+        connector,
+        error: undefined
+      }));
+      const data = await connector.connect();
+
+      if (!didCancel) {
+        // Update connector globally only after successful connection
+        setGlobalState(x => ({ ...x,
           connector,
-          error: undefined
+          data
         }));
-        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
-          }));
-        }
+        setLastUsedConnector(connector.name);
+        setState(x => ({ ...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,
+        error: undefined
+      };
+    } catch (error_) {
+      const error = error_;
 
-        return {
-          data: undefined,
-          error
-        };
+      if (!didCancel) {
+        setState(x => ({ ...x,
+          connector: undefined,
+          error,
+          loading: false
+        }));
       }
-    });
 
-    return function (_x) {
-      return _ref.apply(this, arguments);
-    };
-  }(), [cancelQuery, globalState.connector, setGlobalState, setLastUsedConnector]); // Keep connector in sync with global connector
+      return {
+        data: undefined,
+        error
+      };
+    }
+  }, [cancelQuery, globalState.connector, setGlobalState, setLastUsedConnector]); // Keep connector in sync with global connector
 
   React__namespace.useEffect(() => {
-    setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
+    setState(x => ({ ...x,
       connector: globalState.connector,
       error: undefined
     }));
@@ -919,79 +806,73 @@ var useConnect = () => {
   }, connect];
 };
 
-var initialState$8 = {
+const initialState$8 = {
   loading: false
 };
-var useNetwork = () => {
+const useNetwork = () => {
   var _data$chain, _data$chain2, _connector$chains;
 
-  var {
+  const {
     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()
-      };
+  const [state, setState] = React__namespace.useState(initialState$8);
+  const chainId = data === null || data === void 0 ? void 0 : (_data$chain = data.chain) === null || _data$chain === void 0 ? void 0 : _data$chain.id;
+  const unsupported = data === null || data === void 0 ? void 0 : (_data$chain2 = data.chain) === null || _data$chain2 === void 0 ? void 0 : _data$chain2.unsupported;
+  const activeChains = (_connector$chains = connector === null || connector === void 0 ? void 0 : connector.chains) !== null && _connector$chains !== void 0 ? _connector$chains : [];
+  const activeChain = [...activeChains, ...wagmiCore.allChains].find(x => x.id === chainId);
+  const cancelQuery = useCancel();
+  const switchNetwork = React__namespace.useCallback(async chainId => {
+    let 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);
+    try {
+      setState(x => ({ ...x,
+        error: undefined,
+        loading: true
+      }));
+      const chain = await connector.switchChain(chainId);
 
-        if (!didCancel) {
-          setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
-            loading: false
-          }));
-        }
+      if (!didCancel) {
+        setState(x => ({ ...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: chain,
+        error: undefined
+      };
+    } catch (error_) {
+      const error = error_;
 
-        return {
-          data: undefined,
-          error
-        };
+      if (!didCancel) {
+        setState(x => ({ ...x,
+          error,
+          loading: false
+        }));
       }
-    });
 
-    return function (_x) {
-      return _ref.apply(this, arguments);
-    };
-  }(), [cancelQuery, connector]);
+      return {
+        data: undefined,
+        error
+      };
+    }
+  }, [cancelQuery, connector]);
   return [{
     data: {
-      chain: chainId ? _objectSpread2(_objectSpread2({}, activeChain), {}, {
+      chain: chainId ? { ...activeChain,
         id: chainId,
         unsupported
-      }) : undefined,
+      } : undefined,
       chains: activeChains
     },
     error: state.error,
@@ -999,38 +880,38 @@ var useNetwork = () => {
   }, connector !== null && connector !== void 0 && connector.switchChain ? switchNetwork : undefined];
 };
 
-var initialState$7 = {
+const initialState$7 = {
   data: undefined,
   error: undefined,
   loading: false
 };
-var useSigner = function useSigner() {
-  var {
+const useSigner = function () {
+  let {
     skip
   } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-  var cacheBuster = useCacheBuster();
-  var {
+  const cacheBuster = useCacheBuster();
+  const {
     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;
+  const [state, setState] = React__namespace.useState(initialState$7);
+  const cancelQuery = useCancel();
+  const getSigner = React__namespace.useCallback(async () => {
+    let didCancel = false;
     cancelQuery(() => {
       didCancel = true;
     });
 
     try {
-      setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
+      setState(x => ({ ...x,
         error: undefined,
         loading: true
       }));
-      var signer = yield connector === null || connector === void 0 ? void 0 : connector.getSigner();
+      const signer = await (connector === null || connector === void 0 ? void 0 : connector.getSigner());
 
       if (!didCancel) {
-        setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
+        setState(x => ({ ...x,
           data: signer,
           loading: false
         }));
@@ -1038,17 +919,17 @@ var useSigner = function useSigner() {
 
       return signer;
     } catch (error_) {
-      var error = error_;
+      const error = error_;
 
       if (!didCancel) {
-        setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
+        setState(x => ({ ...x,
           data: undefined,
           error,
           loading: false
         }));
       }
     }
-  }), [cancelQuery, connector]);
+  }, [cancelQuery, connector]);
   /* eslint-disable react-hooks/exhaustive-deps */
 
   React__namespace.useEffect(() => {
@@ -1061,73 +942,67 @@ var useSigner = function useSigner() {
   return [state, getSigner];
 };
 
-var initialState$6 = {
+const initialState$6 = {
   loading: false
 };
-var useSignMessage = function useSignMessage() {
-  var {
+const useSignMessage = function () {
+  let {
     message
   } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-  var {
+  const {
     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;
-      });
+  const [state, setState] = React__namespace.useState(initialState$6);
+  const cancelQuery = useCancel();
+  const signMessage = React__namespace.useCallback(async config => {
+    let 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
+    try {
+      const 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 => ({ ...x,
+        error: undefined,
+        loading: true
+      }));
+      const signer = await connector.getSigner();
+      const signature = await signer.signMessage(config_.message);
+
+      if (!didCancel) {
+        setState(x => ({ ...x,
+          signature,
+          loading: false
         }));
-        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
-          }));
-        }
+      return {
+        data: signature,
+        error: undefined
+      };
+    } catch (error_) {
+      let error = error_;
+      if (error_.code === 4001) error = new wagmiCore.UserRejectedRequestError();
 
-        return {
-          data: undefined,
-          error
-        };
+      if (!didCancel) {
+        setState(x => ({ ...x,
+          error,
+          loading: false
+        }));
       }
-    });
 
-    return function (_x) {
-      return _ref.apply(this, arguments);
-    };
-  }(), [cancelQuery, connector, message]);
+      return {
+        data: undefined,
+        error
+      };
+    }
+  }, [cancelQuery, connector, message]);
   return [{
     data: state.signature,
     error: state.error,
@@ -1135,80 +1010,74 @@ var useSignMessage = function useSignMessage() {
   }, signMessage];
 };
 
-var initialState$5 = {
+const initialState$5 = {
   loading: false
 };
-var useSignTypedData = function useSignTypedData() {
-  var {
+const useSignTypedData = function () {
+  let {
     domain,
     types,
     value
   } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-  var {
+  const {
     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;
-      });
+  const [state, setState] = React__namespace.useState(initialState$5);
+  const cancelQuery = useCancel();
+  const signTypedData = React__namespace.useCallback(async config => {
+    let 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
+    try {
+      const 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 => ({ ...x,
+        error: undefined,
+        loading: true
+      }));
+      const signer = await 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);
+      const signature = await signer._signTypedData(config_.domain, config_.types, config_.value);
 
-        if (!didCancel) {
-          setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
-            signature,
-            loading: false
-          }));
-        }
+      if (!didCancel) {
+        setState(x => ({ ...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
-          }));
-        }
+      return {
+        data: signature,
+        error: undefined
+      };
+    } catch (error_) {
+      let error = error_;
+      if (error_.code === 4001) error = new wagmiCore.UserRejectedRequestError();
 
-        return {
-          data: undefined,
-          error
-        };
+      if (!didCancel) {
+        setState(x => ({ ...x,
+          error,
+          loading: false
+        }));
       }
-    });
 
-    return function (_x) {
-      return _ref.apply(this, arguments);
-    };
-  }(), [cancelQuery, connector, domain, types, value]);
+      return {
+        data: undefined,
+        error
+      };
+    }
+  }, [cancelQuery, connector, domain, types, value]);
   return [{
     data: state.signature,
     error: state.error,
@@ -1216,8 +1085,8 @@ var useSignTypedData = function useSignTypedData() {
   }, signTypedData];
 };
 
-var getContract = _ref => {
-  var {
+const getContract = _ref => {
+  let {
     addressOrName,
     contractInterface,
     signerOrProvider
@@ -1225,8 +1094,8 @@ var getContract = _ref => {
   return new ethers.Contract(addressOrName, contractInterface, signerOrProvider);
 };
 
-var useContract = _ref2 => {
-  var {
+const useContract = _ref2 => {
+  let {
     addressOrName,
     contractInterface,
     signerOrProvider
@@ -1240,21 +1109,22 @@ var useContract = _ref2 => {
   }, [addressOrName, contractInterface, signerOrProvider]);
 };
 
-var useContractEvent = function useContractEvent(contractConfig, eventName, listener) {
-  var {
+const useContractEvent = function (contractConfig, eventName, listener) {
+  let {
     once
   } = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
-  var provider = useProvider();
-  var webSocketProvider = useWebSocketProvider();
-  var contract = useContract(_objectSpread2({
-    signerOrProvider: webSocketProvider !== null && webSocketProvider !== void 0 ? webSocketProvider : provider
-  }, contractConfig));
-  var listenerRef = React__namespace.useRef(listener);
+  const provider = useProvider();
+  const webSocketProvider = useWebSocketProvider();
+  const contract = useContract({
+    signerOrProvider: webSocketProvider !== null && webSocketProvider !== void 0 ? webSocketProvider : provider,
+    ...contractConfig
+  });
+  const listenerRef = React__namespace.useRef(listener);
   listenerRef.current = listener;
   /* eslint-disable react-hooks/exhaustive-deps */
 
   React__namespace.useEffect(() => {
-    var handler = function handler() {
+    const handler = function () {
       for (var _len = arguments.length, event = new Array(_len), _key = 0; _key < _len; _key++) {
         event[_key] = arguments[_key];
       }
@@ -1262,7 +1132,7 @@ var useContractEvent = function useContractEvent(contractConfig, eventName, list
       return listenerRef.current(event);
     };
 
-    var contract_ = contract;
+    const contract_ = contract;
     if (once) contract_.once(eventName, handler);else contract_.on(eventName, handler);
     return () => {
       contract_.off(eventName, handler);
@@ -1271,81 +1141,76 @@ var useContractEvent = function useContractEvent(contractConfig, eventName, list
   /* eslint-enable react-hooks/exhaustive-deps */
 };
 
-var initialState$4 = {
+const initialState$4 = {
   loading: false
 };
-var useContractRead = function useContractRead(contractConfig, functionName) {
-  var {
+const useContractRead = function (contractConfig, functionName) {
+  let {
     args,
     overrides,
     skip,
     watch
   } = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  var cacheBuster = useCacheBuster();
-  var provider = useProvider();
-  var contract = useContract(_objectSpread2({
-    signerOrProvider: provider
-  }, contractConfig));
-  var [{
+  const cacheBuster = useCacheBuster();
+  const provider = useProvider();
+  const contract = useContract({
+    signerOrProvider: provider,
+    ...contractConfig
+  });
+  const [{
     data: blockNumber
   }] = useBlockNumber({
     skip: true,
     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;
-      });
+  const [state, setState] = React__namespace.useState(initialState$4);
+  const cancelQuery = useCancel();
+  const read = React__namespace.useCallback(async config => {
+    let 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);
+    try {
+      const config_ = config !== null && config !== void 0 ? config : {
+        args,
+        overrides
+      };
+      const params = [...(Array.isArray(config_.args) ? config_.args : config_.args ? [config_.args] : []), ...(config_.overrides ? [config_.overrides] : [])];
+      setState(x => ({ ...x,
+        error: undefined,
+        loading: true,
+        response: undefined
+      }));
+      const response = await contract[functionName](...params);
 
-        if (!didCancel) {
-          setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
-            loading: false,
-            response
-          }));
-        }
+      if (!didCancel) {
+        setState(x => ({ ...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: response,
+        error: undefined
+      };
+    } catch (error_) {
+      const error = error_;
 
-        return {
-          data: undefined,
-          error
-        };
+      if (!didCancel) {
+        setState(x => ({ ...x,
+          error,
+          loading: false
+        }));
       }
-    });
 
-    return function (_x) {
-      return _ref.apply(this, arguments);
-    };
-  }(), [args, cancelQuery, contract, functionName, overrides]);
+      return {
+        data: undefined,
+        error
+      };
+    }
+  }, [args, cancelQuery, contract, functionName, overrides]);
   /* eslint-disable react-hooks/exhaustive-deps */
 
   React__namespace.useEffect(() => {
@@ -1372,78 +1237,72 @@ var useContractRead = function useContractRead(contractConfig, functionName) {
   }, read];
 };
 
-var initialState$3 = {
+const initialState$3 = {
   loading: false
 };
-var useContractWrite = function useContractWrite(contractConfig, functionName) {
-  var {
+const useContractWrite = function (contractConfig, functionName) {
+  let {
     args,
     overrides
   } = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  var {
+  const {
     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;
-      });
+  const contract = useContract(contractConfig);
+  const [state, setState] = React__namespace.useState(initialState$3);
+  const cancelQuery = useCancel();
+  const write = React__namespace.useCallback(async config => {
+    let 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
+    try {
+      const config_ = config !== null && config !== void 0 ? config : {
+        args,
+        overrides
+      };
+      if (!connector) throw new wagmiCore.ConnectorNotFoundError();
+      const params = [...(Array.isArray(config_.args) ? config_.args : config_.args ? [config_.args] : []), ...(config_.overrides ? [config_.overrides] : [])];
+      setState(x => ({ ...x,
+        error: undefined,
+        loading: true,
+        response: undefined
+      }));
+      const signer = await connector.getSigner();
+      const contract_ = contract.connect(signer);
+      const response = await contract_[functionName](...params);
+
+      if (!didCancel) {
+        setState(x => ({ ...x,
+          loading: false,
+          response
         }));
-        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: response,
+        error: undefined
+      };
+    } catch (error_) {
+      let error = error_;
+      if (error_.code === 4001) error = new wagmiCore.UserRejectedRequestError();
 
-        return {
-          data: undefined,
-          error
-        };
+      if (!didCancel) {
+        setState(x => ({ ...x,
+          error,
+          loading: false
+        }));
       }
-    });
 
-    return function (_x) {
-      return _ref.apply(this, arguments);
-    };
-  }(), [args, cancelQuery, connector, contract, functionName, overrides]);
+      return {
+        data: undefined,
+        error
+      };
+    }
+  }, [args, cancelQuery, connector, contract, functionName, overrides]);
   return [{
     data: state.response,
     error: state.error,
@@ -1451,103 +1310,91 @@ var useContractWrite = function useContractWrite(contractConfig, functionName) {
   }, write];
 };
 
-var initialState$2 = {
+const initialState$2 = {
   loading: false
 };
-var useToken = function useToken() {
-  var {
+const useToken = function () {
+  let {
     address,
     formatUnits = 'ether',
     skip
   } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-  var {
+  const {
     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;
+  const provider = useProvider();
+  const [state, setState] = React__namespace.useState(initialState$2);
+  const cancelQuery = useCancel();
+  const getToken = React__namespace.useCallback(async config => {
+    let didCancel = false;
+    cancelQuery(() => {
+      didCancel = true;
+    });
 
-        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
-          }));
-        }
+    try {
+      var _config_$formatUnits;
 
-        return {
-          data: token,
-          error: undefined
-        };
-      } catch (error_) {
-        var error = error_;
-
-        if (!didCancel) {
-          setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
-            error,
-            loading: false
-          }));
+      const config_ = config !== null && config !== void 0 ? config : {
+        address,
+        formatUnits
+      };
+      if (!config_.address) throw new Error('address is required');
+      const contract = new ethers.ethers.Contract(config_.address, wagmiCore.erc20ABI, provider);
+      const formatUnits_ = (_config_$formatUnits = config_.formatUnits) !== null && _config_$formatUnits !== void 0 ? _config_$formatUnits : 'ether';
+      setState(x => ({ ...x,
+        error: undefined,
+        loading: true
+      }));
+      const [symbol, decimals, totalSupply] = await Promise.all([contract.symbol(), contract.decimals(), contract.totalSupply()]);
+      const token = {
+        address: config_.address,
+        decimals,
+        symbol,
+        totalSupply: {
+          formatted: ethers.utils.formatUnits(totalSupply, formatUnits_),
+          value: totalSupply
         }
+      };
 
-        return {
-          data: undefined,
-          error
-        };
+      if (!didCancel) {
+        setState(x => ({ ...x,
+          token,
+          loading: false
+        }));
       }
-    });
 
-    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;
+      return {
+        data: token,
+        error: undefined
+      };
+    } catch (error_) {
+      const error = error_;
 
-      try {
-        yield connector.watchAsset(token);
-        return true;
-      } catch (error) {
-        return error;
+      if (!didCancel) {
+        setState(x => ({ ...x,
+          error,
+          loading: false
+        }));
       }
-    });
 
-    return function (_x2) {
-      return _ref2.apply(this, arguments);
-    };
-  }(), [connector]);
+      return {
+        data: undefined,
+        error
+      };
+    }
+  }, [address, cancelQuery, formatUnits, provider]);
+  const watchToken = React__namespace.useCallback(async token => {
+    if (!(connector !== null && connector !== void 0 && connector.watchAsset)) return false;
+
+    try {
+      await connector.watchAsset(token);
+      return true;
+    } catch (error) {
+      return error;
+    }
+  }, [connector]);
   /* eslint-disable react-hooks/exhaustive-deps */
 
   React__namespace.useEffect(() => {
@@ -1561,80 +1408,74 @@ var useToken = function useToken() {
   /* eslint-enable react-hooks/exhaustive-deps */
 
   return [{
-    data: state.token ? _objectSpread2(_objectSpread2({}, state.token), {}, {
+    data: state.token ? { ...state.token,
       address
-    }) : undefined,
+    } : undefined,
     error: state.error,
     loading: state.loading
   }, watchToken, getToken];
 };
 
-var initialState$1 = {
+const initialState$1 = {
   loading: false
 };
-var useTransaction = function useTransaction() {
-  var {
+const useTransaction = function () {
+  let {
     request
   } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-  var {
+  const {
     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;
-      });
+  const [state, setState] = React__namespace.useState(initialState$1);
+  const cancelQuery = useCancel();
+  const sendTransaction = React__namespace.useCallback(async config => {
+    let 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
+    try {
+      const 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 => ({ ...x,
+        loading: true
+      }));
+      const signer = await connector.getSigner();
+      const transaction = await signer.sendTransaction(config_.request);
+
+      if (!didCancel) {
+        setState(x => ({ ...x,
+          loading: false,
+          transaction
         }));
-        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: transaction,
+        error: undefined
+      };
+    } catch (error_) {
+      let error = error_;
+      if (error_.code === 4001) error = new wagmiCore.UserRejectedRequestError();
 
-        return {
-          data: undefined,
-          error
-        };
+      if (!didCancel) {
+        setState(x => ({ ...x,
+          error,
+          loading: false
+        }));
       }
-    });
 
-    return function (_x) {
-      return _ref.apply(this, arguments);
-    };
-  }(), [cancelQuery, connector, request]);
+      return {
+        data: undefined,
+        error
+      };
+    }
+  }, [cancelQuery, connector, request]);
   return [{
     data: state.transaction,
     error: state.error,
@@ -1642,75 +1483,69 @@ var useTransaction = function useTransaction() {
   }, sendTransaction];
 };
 
-var initialState = {
+const initialState = {
   loading: false
 };
-var useWaitForTransaction = function useWaitForTransaction() {
-  var {
+const useWaitForTransaction = function () {
+  let {
     confirmations,
     hash,
     skip,
     timeout,
     wait: wait_
   } = 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;
-      });
+  const provider = useProvider();
+  const [state, setState] = React__namespace.useState(initialState);
+  const cancelQuery = useCancel();
+  const wait = React__namespace.useCallback(async config => {
+    let 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;
+    try {
+      const 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');
+      let promise; // eslint-disable-next-line testing-library/await-async-utils
 
-        if (!didCancel) {
-          setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
-            loading: false,
-            receipt
-          }));
-        }
+      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 => ({ ...x,
+        loading: true
+      }));
+      const receipt = await promise;
 
-        return {
-          data: receipt,
-          error: undefined
-        };
-      } catch (error_) {
-        var error = error_;
-
-        if (!didCancel) {
-          setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
-            error,
-            loading: false
-          }));
-        }
+      if (!didCancel) {
+        setState(x => ({ ...x,
+          loading: false,
+          receipt
+        }));
+      }
 
-        return {
-          data: undefined,
-          error
-        };
+      return {
+        data: receipt,
+        error: undefined
+      };
+    } catch (error_) {
+      const error = error_;
+
+      if (!didCancel) {
+        setState(x => ({ ...x,
+          error,
+          loading: false
+        }));
       }
-    });
 
-    return function (_x) {
-      return _ref.apply(this, arguments);
-    };
-  }(), [cancelQuery, confirmations, hash, provider, timeout, wait_]); // Fetch balance when deps or chain changes
+      return {
+        data: undefined,
+        error
+      };
+    }
+  }, [cancelQuery, confirmations, hash, provider, timeout, wait_]); // Fetch balance when deps or chain changes
 
   /* eslint-disable react-hooks/exhaustive-deps */
 
@@ -1737,11 +1572,11 @@ var useWaitForTransaction = function useWaitForTransaction() {
   }, wait];
 };
 
-var Context = /*#__PURE__*/React__namespace.createContext(null);
-var Provider = _ref => {
+const Context = /*#__PURE__*/React__namespace.createContext(null);
+const Provider = _ref => {
   var _state$data2, _state$data2$chain, _state$data4, _state$data4$chain, _state$data6, _state$data6$chain;
 
-  var {
+  let {
     autoConnect = false,
     children,
     connectors: connectors_ = [new wagmiCore.InjectedConnector()],
@@ -1749,12 +1584,12 @@ var Provider = _ref => {
     provider: provider_ = providers.getDefaultProvider(),
     webSocketProvider: webSocketProvider_
   } = _ref;
-  var [lastUsedConnector, setLastUsedConnector] = useLocalStorage(connectorStorageKey);
-  var [state, setState] = React__namespace.useState({
+  const [lastUsedConnector, setLastUsedConnector] = useLocalStorage(connectorStorageKey);
+  const [state, setState] = React__namespace.useState({
     cacheBuster: 1,
     connecting: autoConnect
   });
-  var connectors = React__namespace.useMemo(() => {
+  const connectors = React__namespace.useMemo(() => {
     var _state$data, _state$data$chain;
 
     if (typeof connectors_ !== 'function') return connectors_;
@@ -1762,7 +1597,7 @@ var Provider = _ref => {
       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(() => {
+  const provider = React__namespace.useMemo(() => {
     var _state$data3, _state$data3$chain;
 
     if (typeof provider_ !== 'function') return provider_;
@@ -1771,7 +1606,7 @@ var Provider = _ref => {
       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(() => {
+  const webSocketProvider = React__namespace.useMemo(() => {
     var _state$data5, _state$data5$chain;
 
     if (!webSocketProvider_) return undefined;
@@ -1787,32 +1622,25 @@ var Provider = _ref => {
   React__namespace.useEffect(() => {
     if (!autoConnect) return;
 
-    _asyncToGenerator(function* () {
-      setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
+    (async () => {
+      setState(x => ({ ...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), {}, {
+      const sorted = lastUsedConnector ? [...connectors].sort(x => x.name === lastUsedConnector ? -1 : 1) : connectors;
+
+      for (const connector of sorted) {
+        if (!connector.ready || !connector.isAuthorized) continue;
+        const isAuthorized = await connector.isAuthorized();
+        if (!isAuthorized) continue;
+        const data = await connector.connect();
+        setState(x => ({ ...x,
           connector,
           data
         }));
-        return "break";
-      };
-
-      for (var connector of sorted) {
-        var _ret = yield* _loop(connector);
-
-        if (_ret === "continue") continue;
-        if (_ret === "break") break;
+        break;
       }
 
-      setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
+      setState(x => ({ ...x,
         connecting: false
       }));
     })();
@@ -1830,16 +1658,18 @@ var Provider = _ref => {
   React__namespace.useEffect(() => {
     if (!state.connector) return;
 
-    var onChange = data => setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
+    const onChange = data => setState(x => ({ ...x,
       cacheBuster: x.cacheBuster + 1,
-      data: _objectSpread2(_objectSpread2({}, x.data), data)
+      data: { ...x.data,
+        ...data
+      }
     }));
 
-    var onDisconnect = () => setState({
+    const onDisconnect = () => setState({
       cacheBuster: 1
     });
 
-    var onError = error => setState(x => _objectSpread2(_objectSpread2({}, x), {}, {
+    const onError = error => setState(x => ({ ...x,
       error
     }));
 
@@ -1853,7 +1683,7 @@ var Provider = _ref => {
       state.connector.off('error', onError);
     };
   }, [state.connector]);
-  var value = {
+  const value = {
     state: {
       cacheBuster: state.cacheBuster,
       connecting: state.connecting,
@@ -1870,8 +1700,8 @@ var Provider = _ref => {
     value
   }, children);
 };
-var useContext = () => {
-  var context = React__namespace.useContext(Context);
+const useContext = () => {
+  const context = React__namespace.useContext(Context);
   if (!context) throw Error('Must be used within Provider');
   return context;
 };