@wagmi/core 0.7.8 → 0.8.0

package/dist/{chunk-HEIMP7HQ.js → chunk-F4A7FMUQ.js}

@@ -1,7 +1,7 @@
 import {
-  defaultChains,
+  goerli,
   mainnet
-} from "./chunk-4DNFSL2K.js";
+} from "./chunk-6KG5TOAU.js";
 import {
   __privateAdd,
   __privateGet,
@@ -19,36 +19,36 @@ import { getAddress, hexValue } from "ethers/lib/utils.js";
 
 // src/utils/configureChains.ts
 import { providers } from "ethers";
-function configureChains(defaultChains2, providers3, {
+function configureChains(defaultChains, providers3, {
   minQuorum = 1,
   pollingInterval = 4e3,
   targetQuorum = 1,
   stallTimeout
 } = {}) {
-  if (!defaultChains2.length)
+  if (!defaultChains.length)
     throw new Error("must have at least one chain");
   if (targetQuorum < minQuorum)
     throw new Error("quorum cannot be lower than minQuorum");
   let chains = [];
   const providers_ = {};
   const webSocketProviders_ = {};
-  for (const chain2 of defaultChains2) {
+  for (const chain of defaultChains) {
     let configExists = false;
     for (const provider of providers3) {
-      const apiConfig = provider(chain2);
+      const apiConfig = provider(chain);
       if (!apiConfig)
         continue;
       configExists = true;
-      if (!chains.some(({ id }) => id === chain2.id)) {
+      if (!chains.some(({ id }) => id === chain.id)) {
         chains = [...chains, apiConfig.chain];
       }
-      providers_[chain2.id] = [
-        ...providers_[chain2.id] || [],
+      providers_[chain.id] = [
+        ...providers_[chain.id] || [],
         apiConfig.provider
       ];
       if (apiConfig.webSocketProvider) {
-        webSocketProviders_[chain2.id] = [
-          ...webSocketProviders_[chain2.id] || [],
+        webSocketProviders_[chain.id] = [
+          ...webSocketProviders_[chain.id] || [],
           apiConfig.webSocketProvider
         ];
       }
@@ -56,7 +56,7 @@ function configureChains(defaultChains2, providers3, {
     if (!configExists) {
       throw new Error(
         [
-          `Could not find valid provider configuration for chain "${chain2.name}".
+          `Could not find valid provider configuration for chain "${chain.name}".
 `,
           "You may need to add `jsonRpcProvider` to `configureChains` with the chain's RPC URLs.",
           "Read more: https://wagmi.sh/react/providers/jsonRpc"
@@ -66,8 +66,8 @@ function configureChains(defaultChains2, providers3, {
   }
   return {
     chains,
-    provider: ({ chainId: chainId2 }) => {
-      const activeChain = chains.find((x) => x.id === chainId2) ?? defaultChains2[0];
+    provider: ({ chainId }) => {
+      const activeChain = chains.find((x) => x.id === chainId) ?? defaultChains[0];
       const chainProviders = providers_[activeChain.id];
       if (!chainProviders || !chainProviders[0])
         throw new Error(`No providers configured for chain "${activeChain.id}"`);
@@ -91,8 +91,8 @@ function configureChains(defaultChains2, providers3, {
         pollingInterval
       });
     },
-    webSocketProvider: ({ chainId: chainId2 }) => {
-      const activeChain = chains.find((x) => x.id === chainId2) ?? defaultChains2[0];
+    webSocketProvider: ({ chainId }) => {
+      const activeChain = chains.find((x) => x.id === chainId) ?? defaultChains[0];
       const chainWebSocketProviders = webSocketProviders_[activeChain.id];
       if (!chainWebSocketProviders)
         return void 0;
@@ -140,23 +140,23 @@ function fallbackProvider(targetQuorum, minQuorum, providers_, { stallTimeout })
 
 // src/utils/assertActiveChain.ts
 function assertActiveChain({
-  chainId: chainId2,
+  chainId,
   signer
 }) {
   const { chain: activeChain, chains } = getNetwork();
   const activeChainId = activeChain?.id;
-  if (activeChainId && chainId2 !== activeChainId) {
+  if (activeChainId && chainId !== activeChainId) {
     throw new ChainMismatchError({
       activeChain: chains.find((x) => x.id === activeChainId)?.name ?? `Chain ${activeChainId}`,
-      targetChain: chains.find((x) => x.id === chainId2)?.name ?? `Chain ${chainId2}`
+      targetChain: chains.find((x) => x.id === chainId)?.name ?? `Chain ${chainId}`
     });
   }
   if (signer) {
     const signerChainId = signer.provider?.network?.chainId;
-    if (signerChainId && chainId2 !== signerChainId) {
+    if (signerChainId && chainId !== signerChainId) {
       const connector = getClient().connector;
       throw new ChainNotConfiguredError({
-        chainId: chainId2,
+        chainId,
         connectorId: connector?.id ?? "unknown"
       });
     }
@@ -398,15 +398,15 @@ function minimizeContractInterface(config) {
 }
 
 // src/utils/normalizeChainId.ts
-function normalizeChainId(chainId2) {
-  if (typeof chainId2 === "string")
+function normalizeChainId(chainId) {
+  if (typeof chainId === "string")
     return Number.parseInt(
-      chainId2,
-      chainId2.trim().substring(0, 2) === "0x" ? 16 : 10
+      chainId,
+      chainId.trim().substring(0, 2) === "0x" ? 16 : 10
     );
-  if (typeof chainId2 === "bigint")
-    return Number(chainId2);
-  return chainId2;
+  if (typeof chainId === "bigint")
+    return Number(chainId);
+  return chainId;
 }
 
 // src/utils/parseContractResult.ts
@@ -490,215 +490,597 @@ function serialize(value, replacer, indent, circularReplacer) {
 
 // src/connectors/base.ts
 import { default as EventEmitter } from "eventemitter3";
+var Connector = class extends EventEmitter {
+  constructor({
+    chains = [mainnet, goerli],
+    options
+  }) {
+    super();
+    this.chains = chains;
+    this.options = options;
+  }
+  getBlockExplorerUrls(chain) {
+    const { default: blockExplorer, ...blockExplorers } = chain.blockExplorers ?? {};
+    if (blockExplorer)
+      return [
+        blockExplorer.url,
+        ...Object.values(blockExplorers).map((x) => x.url)
+      ];
+  }
+  isChainUnsupported(chainId) {
+    return !this.chains.some((x) => x.id === chainId);
+  }
+};
 
-// src/constants/abis.ts
-var erc20ABI = [
-  {
-    type: "event",
-    name: "Approval",
-    inputs: [
-      {
-        indexed: true,
-        name: "owner",
-        type: "address"
-      },
-      {
-        indexed: true,
-        name: "spender",
-        type: "address"
-      },
-      {
-        indexed: false,
-        name: "value",
-        type: "uint256"
-      }
-    ]
-  },
-  {
-    type: "event",
-    name: "Transfer",
-    inputs: [
-      {
-        indexed: true,
-        name: "from",
-        type: "address"
-      },
-      {
-        indexed: true,
-        name: "to",
-        type: "address"
-      },
-      {
-        indexed: false,
-        name: "value",
-        type: "uint256"
+// src/connectors/injected.ts
+var _provider, _switchingChains;
+var InjectedConnector = class extends Connector {
+  constructor({
+    chains,
+    options: options_
+  } = {}) {
+    const options = {
+      shimDisconnect: true,
+      shimChainChangedDisconnect: true,
+      getProvider: () => typeof window !== "undefined" ? window.ethereum : void 0,
+      ...options_
+    };
+    super({ chains, options });
+    __privateAdd(this, _provider, void 0);
+    __privateAdd(this, _switchingChains, void 0);
+    this.shimDisconnectKey = "injected.shimDisconnect";
+    this.onAccountsChanged = (accounts) => {
+      if (accounts.length === 0)
+        this.emit("disconnect");
+      else
+        this.emit("change", {
+          account: getAddress(accounts[0])
+        });
+    };
+    this.onChainChanged = (chainId) => {
+      const id = normalizeChainId(chainId);
+      const unsupported = this.isChainUnsupported(id);
+      this.emit("change", { chain: { id, unsupported } });
+    };
+    this.onDisconnect = () => {
+      if (this.options.shimChainChangedDisconnect && __privateGet(this, _switchingChains)) {
+        __privateSet(this, _switchingChains, false);
+        return;
       }
-    ]
-  },
-  {
-    type: "function",
-    name: "allowance",
-    stateMutability: "view",
-    inputs: [
-      {
-        name: "owner",
-        type: "address"
-      },
-      {
-        name: "spender",
-        type: "address"
+      this.emit("disconnect");
+      if (this.options.shimDisconnect)
+        getClient().storage?.removeItem(this.shimDisconnectKey);
+    };
+    const provider = options.getProvider();
+    if (typeof options.name === "string")
+      this.name = options.name;
+    else if (provider) {
+      const detectedName = getInjectedName(provider);
+      if (options.name)
+        this.name = options.name(detectedName);
+      else {
+        if (typeof detectedName === "string")
+          this.name = detectedName;
+        else
+          this.name = detectedName[0];
       }
-    ],
-    outputs: [
-      {
-        name: "",
-        type: "uint256"
+    } else
+      this.name = "Injected";
+    this.id = "injected";
+    this.ready = !!provider;
+  }
+  async connect({ chainId } = {}) {
+    try {
+      const provider = await this.getProvider();
+      if (!provider)
+        throw new ConnectorNotFoundError();
+      if (provider.on) {
+        provider.on("accountsChanged", this.onAccountsChanged);
+        provider.on("chainChanged", this.onChainChanged);
+        provider.on("disconnect", this.onDisconnect);
       }
-    ]
-  },
-  {
-    type: "function",
-    name: "approve",
-    stateMutability: "nonpayable",
-    inputs: [
-      {
-        name: "spender",
-        type: "address"
-      },
-      {
-        name: "amount",
-        type: "uint256"
+      this.emit("message", { type: "connecting" });
+      const accounts = await provider.request({
+        method: "eth_requestAccounts"
+      });
+      const account = getAddress(accounts[0]);
+      let id = await this.getChainId();
+      let unsupported = this.isChainUnsupported(id);
+      if (chainId && id !== chainId) {
+        const chain = await this.switchChain(chainId);
+        id = chain.id;
+        unsupported = this.isChainUnsupported(id);
       }
-    ],
-    outputs: [
-      {
-        name: "",
-        type: "bool"
+      if (this.options.shimDisconnect)
+        getClient().storage?.setItem(this.shimDisconnectKey, true);
+      return { account, chain: { id, unsupported }, provider };
+    } catch (error) {
+      if (this.isUserRejectedRequestError(error))
+        throw new UserRejectedRequestError(error);
+      if (error.code === -32002)
+        throw new ResourceUnavailableError(error);
+      throw error;
+    }
+  }
+  async disconnect() {
+    const provider = await this.getProvider();
+    if (!provider?.removeListener)
+      return;
+    provider.removeListener("accountsChanged", this.onAccountsChanged);
+    provider.removeListener("chainChanged", this.onChainChanged);
+    provider.removeListener("disconnect", this.onDisconnect);
+    if (this.options.shimDisconnect)
+      getClient().storage?.removeItem(this.shimDisconnectKey);
+  }
+  async getAccount() {
+    const provider = await this.getProvider();
+    if (!provider)
+      throw new ConnectorNotFoundError();
+    const accounts = await provider.request({
+      method: "eth_accounts"
+    });
+    return getAddress(accounts[0]);
+  }
+  async getChainId() {
+    const provider = await this.getProvider();
+    if (!provider)
+      throw new ConnectorNotFoundError();
+    return provider.request({ method: "eth_chainId" }).then(normalizeChainId);
+  }
+  async getProvider() {
+    const provider = this.options.getProvider();
+    if (provider)
+      __privateSet(this, _provider, provider);
+    return __privateGet(this, _provider);
+  }
+  async getSigner({ chainId } = {}) {
+    const [provider, account] = await Promise.all([
+      this.getProvider(),
+      this.getAccount()
+    ]);
+    return new providers2.Web3Provider(
+      provider,
+      chainId
+    ).getSigner(account);
+  }
+  async isAuthorized() {
+    try {
+      if (this.options.shimDisconnect && !getClient().storage?.getItem(this.shimDisconnectKey))
+        return false;
+      const provider = await this.getProvider();
+      if (!provider)
+        throw new ConnectorNotFoundError();
+      const account = await this.getAccount();
+      return !!account;
+    } catch {
+      return false;
+    }
+  }
+  async switchChain(chainId) {
+    if (this.options.shimChainChangedDisconnect)
+      __privateSet(this, _switchingChains, true);
+    const provider = await this.getProvider();
+    if (!provider)
+      throw new ConnectorNotFoundError();
+    const id = hexValue(chainId);
+    try {
+      await provider.request({
+        method: "wallet_switchEthereumChain",
+        params: [{ chainId: id }]
+      });
+      return this.chains.find((x) => x.id === chainId) ?? {
+        id: chainId,
+        name: `Chain ${id}`,
+        network: `${id}`,
+        nativeCurrency: { name: "Ether", decimals: 18, symbol: "ETH" },
+        rpcUrls: { default: { http: [""] } }
+      };
+    } catch (error) {
+      const chain = this.chains.find((x) => x.id === chainId);
+      if (!chain)
+        throw new ChainNotConfiguredError({ chainId, connectorId: this.id });
+      if (error.code === 4902 || error?.data?.originalError?.code === 4902) {
+        try {
+          await provider.request({
+            method: "wallet_addEthereumChain",
+            params: [
+              {
+                chainId: id,
+                chainName: chain.name,
+                nativeCurrency: chain.nativeCurrency,
+                rpcUrls: [
+                  chain.rpcUrls.public?.http[0] ?? chain.rpcUrls.default.http[0] ?? ""
+                ],
+                blockExplorerUrls: this.getBlockExplorerUrls(chain)
+              }
+            ]
+          });
+          return chain;
+        } catch (addError) {
+          if (this.isUserRejectedRequestError(addError))
+            throw new UserRejectedRequestError(error);
+          throw new AddChainError();
+        }
       }
-    ]
-  },
-  {
-    type: "function",
-    name: "balanceOf",
-    stateMutability: "view",
-    inputs: [
-      {
-        name: "account",
-        type: "address"
-      }
-    ],
-    outputs: [
-      {
-        name: "",
-        type: "uint256"
-      }
-    ]
-  },
-  {
-    type: "function",
-    name: "decimals",
-    stateMutability: "view",
-    inputs: [],
-    outputs: [
-      {
-        name: "",
-        type: "uint8"
-      }
-    ]
-  },
-  {
-    type: "function",
-    name: "name",
-    stateMutability: "view",
-    inputs: [],
-    outputs: [
-      {
-        name: "",
-        type: "string"
-      }
-    ]
-  },
-  {
-    type: "function",
-    name: "symbol",
-    stateMutability: "view",
-    inputs: [],
-    outputs: [
-      {
-        name: "",
-        type: "string"
-      }
-    ]
-  },
-  {
-    type: "function",
-    name: "totalSupply",
-    stateMutability: "view",
-    inputs: [],
-    outputs: [
-      {
-        name: "",
-        type: "uint256"
-      }
-    ]
-  },
-  {
-    type: "function",
-    name: "transfer",
-    stateMutability: "nonpayable",
-    inputs: [
-      {
-        name: "recipient",
-        type: "address"
-      },
-      {
-        name: "amount",
-        type: "uint256"
+      if (this.isUserRejectedRequestError(error))
+        throw new UserRejectedRequestError(error);
+      throw new SwitchChainError(error);
+    }
+  }
+  async watchAsset({
+    address,
+    decimals = 18,
+    image,
+    symbol
+  }) {
+    const provider = await this.getProvider();
+    if (!provider)
+      throw new ConnectorNotFoundError();
+    return provider.request({
+      method: "wallet_watchAsset",
+      params: {
+        type: "ERC20",
+        options: {
+          address,
+          decimals,
+          image,
+          symbol
+        }
       }
-    ],
-    outputs: [
-      {
-        name: "",
-        type: "bool"
+    });
+  }
+  isUserRejectedRequestError(error) {
+    return error.code === 4001;
+  }
+};
+_provider = new WeakMap();
+_switchingChains = new WeakMap();
+
+// src/storage.ts
+var noopStorage = {
+  getItem: (_key) => "",
+  setItem: (_key, _value) => null,
+  removeItem: (_key) => null
+};
+function createStorage({
+  deserialize: deserialize2 = deserialize,
+  key: prefix = "wagmi",
+  serialize: serialize2 = serialize,
+  storage
+}) {
+  return {
+    ...storage,
+    getItem: (key, defaultState = null) => {
+      const value = storage.getItem(`${prefix}.${key}`);
+      try {
+        return value ? deserialize2(value) : defaultState;
+      } catch (error) {
+        console.warn(error);
+        return defaultState;
       }
-    ]
-  },
-  {
-    type: "function",
-    name: "transferFrom",
-    stateMutability: "nonpayable",
-    inputs: [
-      {
-        name: "sender",
-        type: "address"
-      },
-      {
-        name: "recipient",
-        type: "address"
-      },
-      {
-        name: "amount",
-        type: "uint256"
+    },
+    setItem: (key, value) => {
+      if (value === null) {
+        storage.removeItem(`${prefix}.${key}`);
+      } else {
+        try {
+          storage.setItem(`${prefix}.${key}`, serialize2(value));
+        } catch (err) {
+          console.error(err);
+        }
       }
-    ],
-    outputs: [
-      {
-        name: "",
-        type: "bool"
+    },
+    removeItem: (key) => storage.removeItem(`${prefix}.${key}`)
+  };
+}
+
+// src/client.ts
+var storeKey = "store";
+var _isAutoConnecting, _lastUsedConnector, _addEffects, addEffects_fn;
+var Client = class {
+  constructor({
+    autoConnect = false,
+    connectors = [new InjectedConnector()],
+    provider,
+    storage = createStorage({
+      storage: typeof window !== "undefined" ? window.localStorage : noopStorage
+    }),
+    logger = {
+      warn: console.warn
+    },
+    webSocketProvider
+  }) {
+    __privateAdd(this, _addEffects);
+    this.providers = /* @__PURE__ */ new Map();
+    this.webSocketProviders = /* @__PURE__ */ new Map();
+    __privateAdd(this, _isAutoConnecting, void 0);
+    __privateAdd(this, _lastUsedConnector, void 0);
+    this.config = {
+      autoConnect,
+      connectors,
+      logger,
+      provider,
+      storage,
+      webSocketProvider
+    };
+    let status = "disconnected";
+    let chainId;
+    if (autoConnect) {
+      try {
+        const rawState = storage.getItem(storeKey, "");
+        const data = JSON.parse(rawState || "{}")?.state?.data;
+        status = data?.account ? "reconnecting" : "connecting";
+        chainId = data?.chain?.id;
+      } catch (_error) {
       }
-    ]
+    }
+    this.store = create(
+      subscribeWithSelector(
+        persist(
+          () => ({
+            connectors: typeof connectors === "function" ? connectors() : connectors,
+            provider: this.getProvider({ chainId }),
+            status,
+            webSocketProvider: this.getWebSocketProvider({ chainId })
+          }),
+          {
+            deserialize: (state) => state,
+            name: storeKey,
+            getStorage: () => storage,
+            partialize: (state) => ({
+              ...autoConnect && {
+                data: {
+                  account: state?.data?.account,
+                  chain: state?.data?.chain
+                }
+              },
+              chains: state?.chains
+            }),
+            serialize: (state) => state,
+            version: 2
+          }
+        )
+      )
+    );
+    this.storage = storage;
+    __privateSet(this, _lastUsedConnector, storage?.getItem("wallet"));
+    __privateMethod(this, _addEffects, addEffects_fn).call(this);
+    if (autoConnect && typeof window !== "undefined")
+      setTimeout(async () => await this.autoConnect(), 0);
   }
-];
-var erc20ABI_bytes32 = [
-  {
-    type: "event",
-    name: "Approval",
-    inputs: [
-      {
-        indexed: true,
-        name: "owner",
-        type: "address"
-      },
+  get chains() {
+    return this.store.getState().chains;
+  }
+  get connectors() {
+    return this.store.getState().connectors;
+  }
+  get connector() {
+    return this.store.getState().connector;
+  }
+  get data() {
+    return this.store.getState().data;
+  }
+  get error() {
+    return this.store.getState().error;
+  }
+  get lastUsedChainId() {
+    return this.data?.chain?.id;
+  }
+  get provider() {
+    return this.store.getState().provider;
+  }
+  get status() {
+    return this.store.getState().status;
+  }
+  get subscribe() {
+    return this.store.subscribe;
+  }
+  get webSocketProvider() {
+    return this.store.getState().webSocketProvider;
+  }
+  setState(updater) {
+    const newState = typeof updater === "function" ? updater(this.store.getState()) : updater;
+    this.store.setState(newState, true);
+  }
+  clearState() {
+    this.setState((x) => ({
+      ...x,
+      chains: void 0,
+      connector: void 0,
+      data: void 0,
+      error: void 0,
+      status: "disconnected"
+    }));
+  }
+  async destroy() {
+    if (this.connector)
+      await this.connector.disconnect?.();
+    __privateSet(this, _isAutoConnecting, false);
+    this.clearState();
+    this.store.destroy();
+  }
+  async autoConnect() {
+    if (__privateGet(this, _isAutoConnecting))
+      return;
+    __privateSet(this, _isAutoConnecting, true);
+    this.setState((x) => ({
+      ...x,
+      status: x.data?.account ? "reconnecting" : "connecting"
+    }));
+    const sorted = __privateGet(this, _lastUsedConnector) ? [...this.connectors].sort(
+      (x) => x.id === __privateGet(this, _lastUsedConnector) ? -1 : 1
+    ) : this.connectors;
+    let connected = false;
+    for (const connector of sorted) {
+      if (!connector.ready || !connector.isAuthorized)
+        continue;
+      const isAuthorized = await connector.isAuthorized();
+      if (!isAuthorized)
+        continue;
+      const data = await connector.connect();
+      this.setState((x) => ({
+        ...x,
+        connector,
+        chains: connector?.chains,
+        data,
+        status: "connected"
+      }));
+      connected = true;
+      break;
+    }
+    if (!connected)
+      this.setState((x) => ({
+        ...x,
+        data: void 0,
+        status: "disconnected"
+      }));
+    __privateSet(this, _isAutoConnecting, false);
+    return this.data;
+  }
+  getProvider({ bust, chainId } = {}) {
+    let provider_ = this.providers.get(chainId ?? -1);
+    if (provider_ && !bust)
+      return provider_;
+    const { provider } = this.config;
+    provider_ = typeof provider === "function" ? provider({ chainId }) : provider;
+    this.providers.set(chainId ?? -1, provider_);
+    return provider_;
+  }
+  getWebSocketProvider({
+    bust,
+    chainId
+  } = {}) {
+    let webSocketProvider_ = this.webSocketProviders.get(chainId ?? -1);
+    if (webSocketProvider_ && !bust)
+      return webSocketProvider_;
+    const { webSocketProvider } = this.config;
+    webSocketProvider_ = typeof webSocketProvider === "function" ? webSocketProvider({ chainId }) : webSocketProvider;
+    if (webSocketProvider_)
+      this.webSocketProviders.set(chainId ?? -1, webSocketProvider_);
+    return webSocketProvider_;
+  }
+  setLastUsedConnector(lastUsedConnector = null) {
+    this.storage?.setItem("wallet", lastUsedConnector);
+  }
+};
+_isAutoConnecting = new WeakMap();
+_lastUsedConnector = new WeakMap();
+_addEffects = new WeakSet();
+addEffects_fn = function() {
+  const onChange = (data) => {
+    this.setState((x) => ({
+      ...x,
+      data: { ...x.data, ...data }
+    }));
+  };
+  const onDisconnect = () => {
+    this.clearState();
+  };
+  const onError = (error) => {
+    this.setState((x) => ({ ...x, error }));
+  };
+  this.store.subscribe(
+    ({ connector }) => connector,
+    (connector, prevConnector) => {
+      prevConnector?.off?.("change", onChange);
+      prevConnector?.off?.("disconnect", onDisconnect);
+      prevConnector?.off?.("error", onError);
+      if (!connector)
+        return;
+      connector.on?.("change", onChange);
+      connector.on?.("disconnect", onDisconnect);
+      connector.on?.("error", onError);
+    }
+  );
+  const { provider, webSocketProvider } = this.config;
+  const subscribeProvider = typeof provider === "function";
+  const subscribeWebSocketProvider = typeof webSocketProvider === "function";
+  if (subscribeProvider || subscribeWebSocketProvider)
+    this.store.subscribe(
+      ({ data }) => data?.chain?.id,
+      (chainId) => {
+        this.setState((x) => ({
+          ...x,
+          provider: this.getProvider({ bust: true, chainId }),
+          webSocketProvider: this.getWebSocketProvider({
+            bust: true,
+            chainId
+          })
+        }));
+      }
+    );
+};
+var client;
+function createClient(config) {
+  const client_ = new Client(config);
+  client = client_;
+  return client_;
+}
+function getClient() {
+  if (!client) {
+    throw new Error(
+      "No wagmi client found. Ensure you have set up a client: https://wagmi.sh/react/client"
+    );
+  }
+  return client;
+}
+
+// src/actions/accounts/connect.ts
+async function connect({
+  chainId,
+  connector
+}) {
+  const client2 = getClient();
+  const activeConnector = client2.connector;
+  if (activeConnector && connector.id === activeConnector.id)
+    throw new ConnectorAlreadyConnectedError();
+  try {
+    client2.setState((x) => ({ ...x, status: "connecting" }));
+    const data = await connector.connect({ chainId });
+    client2.setLastUsedConnector(connector.id);
+    client2.setState((x) => ({
+      ...x,
+      connector,
+      chains: connector?.chains,
+      data,
+      status: "connected"
+    }));
+    client2.storage.setItem("connected", true);
+    return { ...data, connector };
+  } catch (err) {
+    client2.setState((x) => {
+      return {
+        ...x,
+        status: x.connector ? "connected" : "disconnected"
+      };
+    });
+    throw err;
+  }
+}
+
+// src/actions/accounts/disconnect.ts
+async function disconnect() {
+  const client2 = getClient();
+  if (client2.connector)
+    await client2.connector.disconnect();
+  client2.clearState();
+  client2.storage.removeItem("connected");
+}
+
+// src/actions/accounts/fetchBalance.ts
+import { formatUnits as formatUnits3, parseBytes32String as parseBytes32String2 } from "ethers/lib/utils.js";
+
+// src/constants/abis.ts
+var erc20ABI = [
+  {
+    type: "event",
+    name: "Approval",
+    inputs: [
+      {
+        indexed: true,
+        name: "owner",
+        type: "address"
+      },
       {
         indexed: true,
         name: "spender",
@@ -811,7 +1193,7 @@ var erc20ABI_bytes32 = [
     outputs: [
       {
         name: "",
-        type: "bytes32"
+        type: "string"
       }
     ]
   },
@@ -823,7 +1205,7 @@ var erc20ABI_bytes32 = [
     outputs: [
       {
         name: "",
-        type: "bytes32"
+        type: "string"
       }
     ]
   },
@@ -886,7 +1268,7 @@ var erc20ABI_bytes32 = [
     ]
   }
 ];
-var erc721ABI = [
+var erc20ABI_bytes32 = [
   {
     type: "event",
     name: "Approval",
@@ -902,53 +1284,250 @@ var erc721ABI = [
         type: "address"
       },
       {
-        indexed: true,
-        name: "tokenId",
+        indexed: false,
+        name: "value",
         type: "uint256"
       }
     ]
   },
   {
     type: "event",
-    name: "ApprovalForAll",
+    name: "Transfer",
     inputs: [
       {
         indexed: true,
-        name: "owner",
+        name: "from",
         type: "address"
       },
       {
         indexed: true,
-        name: "operator",
+        name: "to",
         type: "address"
       },
       {
         indexed: false,
-        name: "approved",
-        type: "bool"
+        name: "value",
+        type: "uint256"
       }
     ]
   },
   {
-    type: "event",
-    name: "Transfer",
+    type: "function",
+    name: "allowance",
+    stateMutability: "view",
     inputs: [
       {
-        indexed: true,
-        name: "from",
+        name: "owner",
         type: "address"
       },
       {
-        indexed: true,
-        name: "to",
+        name: "spender",
         type: "address"
-      },
-      {
-        indexed: true,
-        name: "tokenId",
-        type: "uint256"
       }
-    ]
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "uint256"
+      }
+    ]
+  },
+  {
+    type: "function",
+    name: "approve",
+    stateMutability: "nonpayable",
+    inputs: [
+      {
+        name: "spender",
+        type: "address"
+      },
+      {
+        name: "amount",
+        type: "uint256"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "bool"
+      }
+    ]
+  },
+  {
+    type: "function",
+    name: "balanceOf",
+    stateMutability: "view",
+    inputs: [
+      {
+        name: "account",
+        type: "address"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "uint256"
+      }
+    ]
+  },
+  {
+    type: "function",
+    name: "decimals",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "uint8"
+      }
+    ]
+  },
+  {
+    type: "function",
+    name: "name",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "bytes32"
+      }
+    ]
+  },
+  {
+    type: "function",
+    name: "symbol",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "bytes32"
+      }
+    ]
+  },
+  {
+    type: "function",
+    name: "totalSupply",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "uint256"
+      }
+    ]
+  },
+  {
+    type: "function",
+    name: "transfer",
+    stateMutability: "nonpayable",
+    inputs: [
+      {
+        name: "recipient",
+        type: "address"
+      },
+      {
+        name: "amount",
+        type: "uint256"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "bool"
+      }
+    ]
+  },
+  {
+    type: "function",
+    name: "transferFrom",
+    stateMutability: "nonpayable",
+    inputs: [
+      {
+        name: "sender",
+        type: "address"
+      },
+      {
+        name: "recipient",
+        type: "address"
+      },
+      {
+        name: "amount",
+        type: "uint256"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "bool"
+      }
+    ]
+  }
+];
+var erc721ABI = [
+  {
+    type: "event",
+    name: "Approval",
+    inputs: [
+      {
+        indexed: true,
+        name: "owner",
+        type: "address"
+      },
+      {
+        indexed: true,
+        name: "spender",
+        type: "address"
+      },
+      {
+        indexed: true,
+        name: "tokenId",
+        type: "uint256"
+      }
+    ]
+  },
+  {
+    type: "event",
+    name: "ApprovalForAll",
+    inputs: [
+      {
+        indexed: true,
+        name: "owner",
+        type: "address"
+      },
+      {
+        indexed: true,
+        name: "operator",
+        type: "address"
+      },
+      {
+        indexed: false,
+        name: "approved",
+        type: "bool"
+      }
+    ]
+  },
+  {
+    type: "event",
+    name: "Transfer",
+    inputs: [
+      {
+        indexed: true,
+        name: "from",
+        type: "address"
+      },
+      {
+        indexed: true,
+        name: "to",
+        type: "address"
+      },
+      {
+        indexed: true,
+        name: "tokenId",
+        type: "uint256"
+      }
+    ]
   },
   {
     type: "function",
@@ -1612,754 +2191,176 @@ var erc4626ABI = [
         name: "shares",
         type: "uint256"
       }
-    ],
-    name: "previewRedeem",
-    outputs: [
-      {
-        name: "assets",
-        type: "uint256"
-      }
-    ],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [
-      {
-        name: "assets",
-        type: "uint256"
-      }
-    ],
-    name: "previewWithdraw",
-    outputs: [
-      {
-        name: "shares",
-        type: "uint256"
-      }
-    ],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [
-      {
-        name: "shares",
-        type: "uint256"
-      },
-      {
-        name: "receiver",
-        type: "address"
-      },
-      {
-        name: "owner",
-        type: "address"
-      }
-    ],
-    name: "redeem",
-    outputs: [
-      {
-        name: "assets",
-        type: "uint256"
-      }
-    ],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    inputs: [],
-    name: "totalAssets",
-    outputs: [
-      {
-        name: "totalManagedAssets",
-        type: "uint256"
-      }
-    ],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [],
-    name: "totalSupply",
-    outputs: [
-      {
-        name: "",
-        type: "uint256"
-      }
-    ],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [
-      {
-        name: "to",
-        type: "address"
-      },
-      {
-        name: "amount",
-        type: "uint256"
-      }
-    ],
-    name: "transfer",
-    outputs: [
-      {
-        name: "",
-        type: "bool"
-      }
-    ],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    inputs: [
-      {
-        name: "from",
-        type: "address"
-      },
-      {
-        name: "to",
-        type: "address"
-      },
-      {
-        name: "amount",
-        type: "uint256"
-      }
-    ],
-    name: "transferFrom",
-    outputs: [
-      {
-        name: "",
-        type: "bool"
-      }
-    ],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    inputs: [
-      {
-        name: "assets",
-        type: "uint256"
-      },
-      {
-        name: "receiver",
-        type: "address"
-      },
-      {
-        name: "owner",
-        type: "address"
-      }
-    ],
-    name: "withdraw",
-    outputs: [
-      {
-        name: "shares",
-        type: "uint256"
-      }
-    ],
-    stateMutability: "nonpayable",
-    type: "function"
-  }
-];
-
-// src/constants/units.ts
-var units = [
-  "wei",
-  "kwei",
-  "mwei",
-  "gwei",
-  "szabo",
-  "finney",
-  "ether"
-];
-
-// src/connectors/base.ts
-var Connector = class extends EventEmitter {
-  constructor({
-    chains = defaultChains,
-    options
-  }) {
-    super();
-    this.chains = chains;
-    this.options = options;
-  }
-  getBlockExplorerUrls(chain2) {
-    const { default: blockExplorer, ...blockExplorers } = chain2.blockExplorers ?? {};
-    if (blockExplorer)
-      return [
-        blockExplorer.url,
-        ...Object.values(blockExplorers).map((x) => x.url)
-      ];
-  }
-  isChainUnsupported(chainId2) {
-    return !this.chains.some((x) => x.id === chainId2);
-  }
-};
-
-// src/connectors/injected.ts
-var _provider, _switchingChains;
-var InjectedConnector = class extends Connector {
-  constructor({
-    chains,
-    options: options_
-  } = {}) {
-    const options = {
-      shimDisconnect: true,
-      shimChainChangedDisconnect: true,
-      getProvider: () => typeof window !== "undefined" ? window.ethereum : void 0,
-      ...options_
-    };
-    super({ chains, options });
-    __privateAdd(this, _provider, void 0);
-    __privateAdd(this, _switchingChains, void 0);
-    this.shimDisconnectKey = "injected.shimDisconnect";
-    this.onAccountsChanged = (accounts) => {
-      if (accounts.length === 0)
-        this.emit("disconnect");
-      else
-        this.emit("change", {
-          account: getAddress(accounts[0])
-        });
-    };
-    this.onChainChanged = (chainId2) => {
-      const id = normalizeChainId(chainId2);
-      const unsupported = this.isChainUnsupported(id);
-      this.emit("change", { chain: { id, unsupported } });
-    };
-    this.onDisconnect = () => {
-      if (this.options.shimChainChangedDisconnect && __privateGet(this, _switchingChains)) {
-        __privateSet(this, _switchingChains, false);
-        return;
-      }
-      this.emit("disconnect");
-      if (this.options.shimDisconnect)
-        getClient().storage?.removeItem(this.shimDisconnectKey);
-    };
-    const provider = options.getProvider();
-    if (typeof options.name === "string")
-      this.name = options.name;
-    else if (provider) {
-      const detectedName = getInjectedName(provider);
-      if (options.name)
-        this.name = options.name(detectedName);
-      else {
-        if (typeof detectedName === "string")
-          this.name = detectedName;
-        else
-          this.name = detectedName[0];
-      }
-    } else
-      this.name = "Injected";
-    this.id = "injected";
-    this.ready = !!provider;
-  }
-  async connect({ chainId: chainId2 } = {}) {
-    try {
-      const provider = await this.getProvider();
-      if (!provider)
-        throw new ConnectorNotFoundError();
-      if (provider.on) {
-        provider.on("accountsChanged", this.onAccountsChanged);
-        provider.on("chainChanged", this.onChainChanged);
-        provider.on("disconnect", this.onDisconnect);
-      }
-      this.emit("message", { type: "connecting" });
-      const accounts = await provider.request({
-        method: "eth_requestAccounts"
-      });
-      const account = getAddress(accounts[0]);
-      let id = await this.getChainId();
-      let unsupported = this.isChainUnsupported(id);
-      if (chainId2 && id !== chainId2) {
-        const chain2 = await this.switchChain(chainId2);
-        id = chain2.id;
-        unsupported = this.isChainUnsupported(id);
-      }
-      if (this.options.shimDisconnect)
-        getClient().storage?.setItem(this.shimDisconnectKey, true);
-      return { account, chain: { id, unsupported }, provider };
-    } catch (error) {
-      if (this.isUserRejectedRequestError(error))
-        throw new UserRejectedRequestError(error);
-      if (error.code === -32002)
-        throw new ResourceUnavailableError(error);
-      throw error;
-    }
-  }
-  async disconnect() {
-    const provider = await this.getProvider();
-    if (!provider?.removeListener)
-      return;
-    provider.removeListener("accountsChanged", this.onAccountsChanged);
-    provider.removeListener("chainChanged", this.onChainChanged);
-    provider.removeListener("disconnect", this.onDisconnect);
-    if (this.options.shimDisconnect)
-      getClient().storage?.removeItem(this.shimDisconnectKey);
-  }
-  async getAccount() {
-    const provider = await this.getProvider();
-    if (!provider)
-      throw new ConnectorNotFoundError();
-    const accounts = await provider.request({
-      method: "eth_accounts"
-    });
-    return getAddress(accounts[0]);
-  }
-  async getChainId() {
-    const provider = await this.getProvider();
-    if (!provider)
-      throw new ConnectorNotFoundError();
-    return provider.request({ method: "eth_chainId" }).then(normalizeChainId);
-  }
-  async getProvider() {
-    const provider = this.options.getProvider();
-    if (provider)
-      __privateSet(this, _provider, provider);
-    return __privateGet(this, _provider);
-  }
-  async getSigner({ chainId: chainId2 } = {}) {
-    const [provider, account] = await Promise.all([
-      this.getProvider(),
-      this.getAccount()
-    ]);
-    return new providers2.Web3Provider(
-      provider,
-      chainId2
-    ).getSigner(account);
-  }
-  async isAuthorized() {
-    try {
-      if (this.options.shimDisconnect && !getClient().storage?.getItem(this.shimDisconnectKey))
-        return false;
-      const provider = await this.getProvider();
-      if (!provider)
-        throw new ConnectorNotFoundError();
-      const account = await this.getAccount();
-      return !!account;
-    } catch {
-      return false;
-    }
-  }
-  async switchChain(chainId2) {
-    if (this.options.shimChainChangedDisconnect)
-      __privateSet(this, _switchingChains, true);
-    const provider = await this.getProvider();
-    if (!provider)
-      throw new ConnectorNotFoundError();
-    const id = hexValue(chainId2);
-    try {
-      await provider.request({
-        method: "wallet_switchEthereumChain",
-        params: [{ chainId: id }]
-      });
-      return this.chains.find((x) => x.id === chainId2) ?? {
-        id: chainId2,
-        name: `Chain ${id}`,
-        network: `${id}`,
-        rpcUrls: { default: "" }
-      };
-    } catch (error) {
-      const chain2 = this.chains.find((x) => x.id === chainId2);
-      if (!chain2)
-        throw new ChainNotConfiguredError({ chainId: chainId2, connectorId: this.id });
-      if (error.code === 4902 || error?.data?.originalError?.code === 4902) {
-        try {
-          await provider.request({
-            method: "wallet_addEthereumChain",
-            params: [
-              {
-                chainId: id,
-                chainName: chain2.name,
-                nativeCurrency: chain2.nativeCurrency,
-                rpcUrls: [chain2.rpcUrls.public ?? chain2.rpcUrls.default],
-                blockExplorerUrls: this.getBlockExplorerUrls(chain2)
-              }
-            ]
-          });
-          return chain2;
-        } catch (addError) {
-          if (this.isUserRejectedRequestError(addError))
-            throw new UserRejectedRequestError(error);
-          throw new AddChainError();
-        }
-      }
-      if (this.isUserRejectedRequestError(error))
-        throw new UserRejectedRequestError(error);
-      throw new SwitchChainError(error);
-    }
-  }
-  async watchAsset({
-    address,
-    decimals = 18,
-    image,
-    symbol
-  }) {
-    const provider = await this.getProvider();
-    if (!provider)
-      throw new ConnectorNotFoundError();
-    return provider.request({
-      method: "wallet_watchAsset",
-      params: {
-        type: "ERC20",
-        options: {
-          address,
-          decimals,
-          image,
-          symbol
-        }
-      }
-    });
-  }
-  isUserRejectedRequestError(error) {
-    return error.code === 4001;
-  }
-};
-_provider = new WeakMap();
-_switchingChains = new WeakMap();
-
-// src/storage.ts
-var noopStorage = {
-  getItem: (_key) => "",
-  setItem: (_key, _value) => null,
-  removeItem: (_key) => null
-};
-function createStorage({
-  deserialize: deserialize2 = deserialize,
-  key: prefix = "wagmi",
-  serialize: serialize2 = serialize,
-  storage
-}) {
-  return {
-    ...storage,
-    getItem: (key, defaultState = null) => {
-      const value = storage.getItem(`${prefix}.${key}`);
-      try {
-        return value ? deserialize2(value) : defaultState;
-      } catch (error) {
-        console.warn(error);
-        return defaultState;
-      }
-    },
-    setItem: (key, value) => {
-      if (value === null) {
-        storage.removeItem(`${prefix}.${key}`);
-      } else {
-        try {
-          storage.setItem(`${prefix}.${key}`, serialize2(value));
-        } catch (err) {
-          console.error(err);
-        }
-      }
-    },
-    removeItem: (key) => storage.removeItem(`${prefix}.${key}`)
-  };
-}
-
-// src/client.ts
-var storeKey = "store";
-var _isAutoConnecting, _lastUsedConnector, _addEffects, addEffects_fn;
-var Client = class {
-  constructor({
-    autoConnect = false,
-    connectors = [new InjectedConnector()],
-    provider,
-    storage = createStorage({
-      storage: typeof window !== "undefined" ? window.localStorage : noopStorage
-    }),
-    logger = {
-      warn: console.warn
-    },
-    webSocketProvider
-  }) {
-    __privateAdd(this, _addEffects);
-    this.providers = /* @__PURE__ */ new Map();
-    this.webSocketProviders = /* @__PURE__ */ new Map();
-    __privateAdd(this, _isAutoConnecting, void 0);
-    __privateAdd(this, _lastUsedConnector, void 0);
-    this.config = {
-      autoConnect,
-      connectors,
-      logger,
-      provider,
-      storage,
-      webSocketProvider
-    };
-    let status = "disconnected";
-    let chainId2;
-    if (autoConnect) {
-      try {
-        const rawState = storage.getItem(storeKey, "");
-        const data = JSON.parse(rawState || "{}")?.state?.data;
-        status = data?.account ? "reconnecting" : "connecting";
-        chainId2 = data?.chain?.id;
-      } catch (_error) {
-      }
-    }
-    this.store = create(
-      subscribeWithSelector(
-        persist(
-          () => ({
-            connectors: typeof connectors === "function" ? connectors() : connectors,
-            provider: this.getProvider({ chainId: chainId2 }),
-            status,
-            webSocketProvider: this.getWebSocketProvider({ chainId: chainId2 })
-          }),
-          {
-            deserialize: (state) => state,
-            name: storeKey,
-            getStorage: () => storage,
-            partialize: (state) => ({
-              ...autoConnect && {
-                data: {
-                  account: state?.data?.account,
-                  chain: state?.data?.chain
-                }
-              },
-              chains: state?.chains
-            }),
-            serialize: (state) => state,
-            version: 2
-          }
-        )
-      )
-    );
-    this.storage = storage;
-    __privateSet(this, _lastUsedConnector, storage?.getItem("wallet"));
-    __privateMethod(this, _addEffects, addEffects_fn).call(this);
-    if (autoConnect && typeof window !== "undefined")
-      setTimeout(async () => await this.autoConnect(), 0);
-  }
-  get chains() {
-    return this.store.getState().chains;
-  }
-  get connectors() {
-    return this.store.getState().connectors;
-  }
-  get connector() {
-    return this.store.getState().connector;
-  }
-  get data() {
-    return this.store.getState().data;
-  }
-  get error() {
-    return this.store.getState().error;
-  }
-  get lastUsedChainId() {
-    return this.data?.chain?.id;
-  }
-  get provider() {
-    return this.store.getState().provider;
-  }
-  get status() {
-    return this.store.getState().status;
-  }
-  get subscribe() {
-    return this.store.subscribe;
-  }
-  get webSocketProvider() {
-    return this.store.getState().webSocketProvider;
-  }
-  setState(updater) {
-    const newState = typeof updater === "function" ? updater(this.store.getState()) : updater;
-    this.store.setState(newState, true);
-  }
-  clearState() {
-    this.setState((x) => ({
-      ...x,
-      chains: void 0,
-      connector: void 0,
-      data: void 0,
-      error: void 0,
-      status: "disconnected"
-    }));
-  }
-  async destroy() {
-    if (this.connector)
-      await this.connector.disconnect?.();
-    __privateSet(this, _isAutoConnecting, false);
-    this.clearState();
-    this.store.destroy();
-  }
-  async autoConnect() {
-    if (__privateGet(this, _isAutoConnecting))
-      return;
-    __privateSet(this, _isAutoConnecting, true);
-    this.setState((x) => ({
-      ...x,
-      status: x.data?.account ? "reconnecting" : "connecting"
-    }));
-    const sorted = __privateGet(this, _lastUsedConnector) ? [...this.connectors].sort(
-      (x) => x.id === __privateGet(this, _lastUsedConnector) ? -1 : 1
-    ) : this.connectors;
-    let connected = false;
-    for (const connector of sorted) {
-      if (!connector.ready || !connector.isAuthorized)
-        continue;
-      const isAuthorized = await connector.isAuthorized();
-      if (!isAuthorized)
-        continue;
-      const data = await connector.connect();
-      this.setState((x) => ({
-        ...x,
-        connector,
-        chains: connector?.chains,
-        data,
-        status: "connected"
-      }));
-      connected = true;
-      break;
-    }
-    if (!connected)
-      this.setState((x) => ({
-        ...x,
-        data: void 0,
-        status: "disconnected"
-      }));
-    __privateSet(this, _isAutoConnecting, false);
-    return this.data;
-  }
-  getProvider({ bust, chainId: chainId2 } = {}) {
-    let provider_ = this.providers.get(chainId2 ?? -1);
-    if (provider_ && !bust)
-      return provider_;
-    const { provider } = this.config;
-    provider_ = typeof provider === "function" ? provider({ chainId: chainId2 }) : provider;
-    this.providers.set(chainId2 ?? -1, provider_);
-    return provider_;
-  }
-  getWebSocketProvider({
-    bust,
-    chainId: chainId2
-  } = {}) {
-    let webSocketProvider_ = this.webSocketProviders.get(chainId2 ?? -1);
-    if (webSocketProvider_ && !bust)
-      return webSocketProvider_;
-    const { webSocketProvider } = this.config;
-    webSocketProvider_ = typeof webSocketProvider === "function" ? webSocketProvider({ chainId: chainId2 }) : webSocketProvider;
-    if (webSocketProvider_)
-      this.webSocketProviders.set(chainId2 ?? -1, webSocketProvider_);
-    return webSocketProvider_;
-  }
-  setLastUsedConnector(lastUsedConnector = null) {
-    this.storage?.setItem("wallet", lastUsedConnector);
-  }
-};
-_isAutoConnecting = new WeakMap();
-_lastUsedConnector = new WeakMap();
-_addEffects = new WeakSet();
-addEffects_fn = function() {
-  const onChange = (data) => {
-    this.setState((x) => ({
-      ...x,
-      data: { ...x.data, ...data }
-    }));
-  };
-  const onDisconnect = () => {
-    this.clearState();
-  };
-  const onError = (error) => {
-    this.setState((x) => ({ ...x, error }));
-  };
-  this.store.subscribe(
-    ({ connector }) => connector,
-    (connector, prevConnector) => {
-      prevConnector?.off?.("change", onChange);
-      prevConnector?.off?.("disconnect", onDisconnect);
-      prevConnector?.off?.("error", onError);
-      if (!connector)
-        return;
-      connector.on?.("change", onChange);
-      connector.on?.("disconnect", onDisconnect);
-      connector.on?.("error", onError);
-    }
-  );
-  const { provider, webSocketProvider } = this.config;
-  const subscribeProvider = typeof provider === "function";
-  const subscribeWebSocketProvider = typeof webSocketProvider === "function";
-  if (subscribeProvider || subscribeWebSocketProvider)
-    this.store.subscribe(
-      ({ data }) => data?.chain?.id,
-      (chainId2) => {
-        this.setState((x) => ({
-          ...x,
-          provider: this.getProvider({ bust: true, chainId: chainId2 }),
-          webSocketProvider: this.getWebSocketProvider({
-            bust: true,
-            chainId: chainId2
-          })
-        }));
-      }
-    );
-};
-var client;
-function createClient(config) {
-  const client_ = new Client(config);
-  client = client_;
-  return client_;
-}
-function getClient() {
-  if (!client) {
-    throw new Error(
-      "No wagmi client found. Ensure you have set up a client: https://wagmi.sh/react/client"
-    );
-  }
-  return client;
-}
-
-// src/actions/accounts/connect.ts
-async function connect({
-  chainId: chainId2,
-  connector
-}) {
-  const client2 = getClient();
-  const activeConnector = client2.connector;
-  if (activeConnector && connector.id === activeConnector.id)
-    throw new ConnectorAlreadyConnectedError();
-  try {
-    client2.setState((x) => ({ ...x, status: "connecting" }));
-    const data = await connector.connect({ chainId: chainId2 });
-    client2.setLastUsedConnector(connector.id);
-    client2.setState((x) => ({
-      ...x,
-      connector,
-      chains: connector?.chains,
-      data,
-      status: "connected"
-    }));
-    client2.storage.setItem("connected", true);
-    return { ...data, connector };
-  } catch (err) {
-    client2.setState((x) => {
-      return {
-        ...x,
-        status: x.connector ? "connected" : "disconnected"
-      };
-    });
-    throw err;
+    ],
+    name: "previewRedeem",
+    outputs: [
+      {
+        name: "assets",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        name: "assets",
+        type: "uint256"
+      }
+    ],
+    name: "previewWithdraw",
+    outputs: [
+      {
+        name: "shares",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        name: "shares",
+        type: "uint256"
+      },
+      {
+        name: "receiver",
+        type: "address"
+      },
+      {
+        name: "owner",
+        type: "address"
+      }
+    ],
+    name: "redeem",
+    outputs: [
+      {
+        name: "assets",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "totalAssets",
+    outputs: [
+      {
+        name: "totalManagedAssets",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "totalSupply",
+    outputs: [
+      {
+        name: "",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        name: "to",
+        type: "address"
+      },
+      {
+        name: "amount",
+        type: "uint256"
+      }
+    ],
+    name: "transfer",
+    outputs: [
+      {
+        name: "",
+        type: "bool"
+      }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        name: "from",
+        type: "address"
+      },
+      {
+        name: "to",
+        type: "address"
+      },
+      {
+        name: "amount",
+        type: "uint256"
+      }
+    ],
+    name: "transferFrom",
+    outputs: [
+      {
+        name: "",
+        type: "bool"
+      }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        name: "assets",
+        type: "uint256"
+      },
+      {
+        name: "receiver",
+        type: "address"
+      },
+      {
+        name: "owner",
+        type: "address"
+      }
+    ],
+    name: "withdraw",
+    outputs: [
+      {
+        name: "shares",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
   }
-}
-
-// src/actions/accounts/disconnect.ts
-async function disconnect() {
-  const client2 = getClient();
-  if (client2.connector)
-    await client2.connector.disconnect();
-  client2.clearState();
-  client2.storage.removeItem("connected");
-}
+];
 
-// src/actions/accounts/fetchBalance.ts
-import { formatUnits as formatUnits2, parseBytes32String as parseBytes32String2 } from "ethers/lib/utils.js";
+// src/constants/units.ts
+var units = [
+  "wei",
+  "kwei",
+  "mwei",
+  "gwei",
+  "szabo",
+  "finney",
+  "ether"
+];
 
 // src/actions/contracts/fetchToken.ts
 import { formatUnits, parseBytes32String } from "ethers/lib/utils.js";
 async function fetchToken({
   address,
-  chainId: chainId2,
+  chainId,
   formatUnits: units2 = "ether"
 }) {
   async function fetchToken_({ abi }) {
-    const erc20Config = { address, abi, chainId: chainId2 };
+    const erc20Config = { address, abi, chainId };
     const [decimals, name, symbol, totalSupply] = await readContracts({
       allowFailure: false,
       contracts: [
@@ -2416,16 +2417,16 @@ async function prepareWriteContract({
   abi,
   address,
   args,
-  chainId: chainId2,
+  chainId,
   functionName,
   overrides,
   signer: signer_
 }) {
-  const signer = signer_ ?? await fetchSigner({ chainId: chainId2 });
+  const signer = signer_ ?? await fetchSigner({ chainId });
   if (!signer)
     throw new ConnectorNotFoundError();
-  if (chainId2)
-    assertActiveChain({ chainId: chainId2, signer });
+  if (chainId)
+    assertActiveChain({ chainId, signer });
   const contract = getContract({
     address,
     abi,
@@ -2454,7 +2455,7 @@ async function prepareWriteContract({
   return {
     abi: minimizedAbi,
     address,
-    chainId: chainId2,
+    chainId,
     functionName,
     mode: "prepared",
     request: {
@@ -2466,21 +2467,21 @@ async function prepareWriteContract({
 
 // src/actions/providers/getProvider.ts
 function getProvider({
-  chainId: chainId2
+  chainId
 } = {}) {
   const client2 = getClient();
-  if (chainId2)
-    return client2.getProvider({ chainId: chainId2 }) || client2.provider;
+  if (chainId)
+    return client2.getProvider({ chainId }) || client2.provider;
   return client2.provider;
 }
 
 // src/actions/providers/getWebSocketProvider.ts
 function getWebSocketProvider({
-  chainId: chainId2
+  chainId
 } = {}) {
   const client2 = getClient();
-  if (chainId2)
-    return client2.getWebSocketProvider({ chainId: chainId2 }) || client2.webSocketProvider;
+  if (chainId)
+    return client2.getWebSocketProvider({ chainId }) || client2.webSocketProvider;
   return client2.webSocketProvider;
 }
 
@@ -2506,25 +2507,25 @@ function watchWebSocketProvider(args, callback) {
 // src/actions/contracts/multicall.ts
 async function multicall({
   allowFailure = true,
-  chainId: chainId2,
+  chainId,
   contracts,
   overrides
 }) {
-  const provider = getProvider({ chainId: chainId2 });
+  const provider = getProvider({ chainId });
   if (!provider.chains)
     throw new ProviderChainsNotFound();
-  const chain2 = provider.chains.find((chain3) => chain3.id === chainId2) || provider.chains[0];
-  if (!chain2)
+  const chain = provider.chains.find((chain2) => chain2.id === chainId) || provider.chains[0];
+  if (!chain)
     throw new ProviderChainsNotFound();
-  if (!chain2?.multicall)
-    throw new ChainDoesNotSupportMulticallError({ chain: chain2 });
-  if (typeof overrides?.blockTag === "number" && overrides?.blockTag < chain2.multicall.blockCreated)
+  if (!chain?.contracts?.multicall3)
+    throw new ChainDoesNotSupportMulticallError({ chain });
+  if (typeof overrides?.blockTag === "number" && overrides?.blockTag < (chain.contracts.multicall3.blockCreated ?? 0))
     throw new ChainDoesNotSupportMulticallError({
       blockNumber: overrides?.blockTag,
-      chain: chain2
+      chain
     });
   const multicallContract = getContract({
-    address: chain2.multicall.address,
+    address: chain.contracts.multicall3.address,
     abi: multicallABI,
     signerOrProvider: provider
   });
@@ -2590,7 +2591,7 @@ async function multicall({
         error = new ContractMethodRevertedError({
           address,
           args,
-          chainId: chain2.id,
+          chainId: chain.id,
           functionName: normalizedFunctionName,
           errorMessage: err.message
         });
@@ -2604,7 +2605,7 @@ async function multicall({
       const error = new ContractMethodNoResultError({
         address,
         args,
-        chainId: chain2.id,
+        chainId: chain.id,
         functionName: normalizedFunctionName
       });
       if (!allowFailure)
@@ -2622,7 +2623,7 @@ async function multicall({
       const error = new ContractResultDecodeError({
         address,
         args,
-        chainId: chain2.id,
+        chainId: chain.id,
         functionName: normalizedFunctionName,
         errorMessage: err.message
       });
@@ -2638,12 +2639,12 @@ async function multicall({
 async function readContract({
   address,
   args,
-  chainId: chainId2,
+  chainId,
   abi,
   functionName,
   overrides
 }) {
-  const provider = getProvider({ chainId: chainId2 });
+  const provider = getProvider({ chainId });
   const contract = getContract({
     address,
     abi,
@@ -2673,16 +2674,16 @@ async function readContracts({
   try {
     const provider = getProvider();
     const contractsByChainId = contracts.reduce((contracts2, contract, index) => {
-      const chainId2 = contract.chainId ?? provider.network.chainId;
+      const chainId = contract.chainId ?? provider.network.chainId;
       return {
         ...contracts2,
-        [chainId2]: [...contracts2[chainId2] || [], { contract, index }]
+        [chainId]: [...contracts2[chainId] || [], { contract, index }]
       };
     }, {});
     const promises = () => Object.entries(contractsByChainId).map(
-      ([chainId2, contracts2]) => multicall({
+      ([chainId, contracts2]) => multicall({
         allowFailure,
-        chainId: parseInt(chainId2),
+        chainId: parseInt(chainId),
         contracts: contracts2.map(({ contract }) => contract),
         overrides
       })
@@ -2721,11 +2722,11 @@ async function readContracts({
       return (await Promise.allSettled(promises())).map((result, i) => {
         if (result.status === "fulfilled")
           return result.value;
-        const { address, args, chainId: chainId2, functionName } = contracts[i];
+        const { address, args, chainId, functionName } = contracts[i];
         const error = new ContractMethodRevertedError({
           address,
           functionName,
-          chainId: chainId2 ?? mainnet.id,
+          chainId: chainId ?? 1,
           args,
           errorMessage: result.reason
         });
@@ -2741,7 +2742,7 @@ import shallow from "zustand/shallow";
 function watchContractEvent({
   address,
   abi,
-  chainId: chainId2,
+  chainId,
   eventName,
   once
 }, callback) {
@@ -2750,7 +2751,7 @@ function watchContractEvent({
   const watchEvent = async () => {
     if (contract)
       contract?.off(eventName, handler);
-    const signerOrProvider = getWebSocketProvider({ chainId: chainId2 }) || getProvider({ chainId: chainId2 });
+    const signerOrProvider = getWebSocketProvider({ chainId }) || getProvider({ chainId });
     contract = getContract({
       address,
       abi,
@@ -2782,9 +2783,9 @@ import shallow2 from "zustand/shallow";
 
 // src/actions/network-status/fetchBlockNumber.ts
 async function fetchBlockNumber({
-  chainId: chainId2
+  chainId
 } = {}) {
-  const provider = getProvider({ chainId: chainId2 });
+  const provider = getProvider({ chainId });
   const blockNumber = await provider.getBlockNumber();
   return blockNumber;
 }
@@ -2867,10 +2868,10 @@ function watchReadContracts(config, callback) {
 
 // src/actions/transactions/fetchTransaction.ts
 async function fetchTransaction({
-  chainId: chainId2,
+  chainId,
   hash
 }) {
-  const provider = getProvider({ chainId: chainId2 });
+  const provider = getProvider({ chainId });
   return provider.getTransaction(hash);
 }
 
@@ -2880,10 +2881,10 @@ import { isAddress as isAddress2 } from "ethers/lib/utils.js";
 // src/actions/ens/fetchEnsAddress.ts
 import { getAddress as getAddress2 } from "ethers/lib/utils.js";
 async function fetchEnsAddress({
-  chainId: chainId2,
+  chainId,
   name
 }) {
-  const provider = getProvider({ chainId: chainId2 });
+  const provider = getProvider({ chainId });
   const address = await provider.resolveName(name);
   try {
     return address ? getAddress2(address) : null;
@@ -2895,9 +2896,9 @@ async function fetchEnsAddress({
 // src/actions/ens/fetchEnsAvatar.ts
 async function fetchEnsAvatar({
   address,
-  chainId: chainId2
+  chainId
 }) {
-  const provider = getProvider({ chainId: chainId2 });
+  const provider = getProvider({ chainId });
   const avatar = await provider.getAvatar(address);
   return avatar;
 }
@@ -2906,33 +2907,33 @@ async function fetchEnsAvatar({
 import { getAddress as getAddress3 } from "ethers/lib/utils.js";
 async function fetchEnsName({
   address,
-  chainId: chainId2
+  chainId
 }) {
-  const provider = getProvider({ chainId: chainId2 });
+  const provider = getProvider({ chainId });
   return provider.lookupAddress(getAddress3(address));
 }
 
 // src/actions/ens/fetchEnsResolver.ts
 async function fetchEnsResolver({
-  chainId: chainId2,
+  chainId,
   name
 }) {
-  const provider = getProvider({ chainId: chainId2 });
+  const provider = getProvider({ chainId });
   const resolver = await provider.getResolver(name);
   return resolver;
 }
 
 // src/actions/transactions/prepareSendTransaction.ts
 async function prepareSendTransaction({
-  chainId: chainId2,
+  chainId,
   request,
   signer: signer_
 }) {
-  const signer = signer_ ?? await fetchSigner({ chainId: chainId2 });
+  const signer = signer_ ?? await fetchSigner({ chainId });
   if (!signer)
     throw new ConnectorNotFoundError();
-  if (chainId2)
-    assertActiveChain({ chainId: chainId2, signer });
+  if (chainId)
+    assertActiveChain({ chainId, signer });
   const [to, gasLimit] = await Promise.all([
     isAddress2(request.to) ? Promise.resolve(request.to) : fetchEnsAddress({ name: request.to }),
     request.gasLimit ? Promise.resolve(request.gasLimit) : signer.estimateGas(request)
@@ -2940,7 +2941,7 @@ async function prepareSendTransaction({
   if (!to)
     throw new Error("Could not resolve ENS name");
   return {
-    ...chainId2 ? { chainId: chainId2 } : {},
+    ...chainId ? { chainId } : {},
     request: { ...request, gasLimit, to },
     mode: "prepared"
   };
@@ -2948,7 +2949,7 @@ async function prepareSendTransaction({
 
 // src/actions/transactions/sendTransaction.ts
 async function sendTransaction({
-  chainId: chainId2,
+  chainId,
   mode,
   request
 }) {
@@ -2961,8 +2962,8 @@ async function sendTransaction({
     if (!request.to)
       throw new Error("`to` is required");
   }
-  if (chainId2)
-    assertActiveChain({ chainId: chainId2, signer });
+  if (chainId)
+    assertActiveChain({ chainId, signer });
   try {
     const uncheckedSigner = signer.connectUnchecked?.();
     const { hash, wait } = await (uncheckedSigner ?? signer).sendTransaction(
@@ -2976,30 +2977,80 @@ async function sendTransaction({
   }
 }
 
+// src/actions/transactions/waitForTransaction.ts
+import { toUtf8String } from "ethers/lib/utils.js";
+
+// src/actions/network-status/fetchFeeData.ts
+import { formatUnits as formatUnits2 } from "ethers/lib/utils.js";
+async function fetchFeeData({
+  chainId,
+  formatUnits: units2 = "wei"
+} = {}) {
+  const provider = getProvider({ chainId });
+  const feeData = await provider.getFeeData();
+  const formatted = {
+    gasPrice: feeData.gasPrice ? formatUnits2(feeData.gasPrice, units2) : null,
+    maxFeePerGas: feeData.maxFeePerGas ? formatUnits2(feeData.maxFeePerGas, units2) : null,
+    maxPriorityFeePerGas: feeData.maxPriorityFeePerGas ? formatUnits2(feeData.maxPriorityFeePerGas, units2) : null
+  };
+  return { ...feeData, formatted };
+}
+
 // src/actions/transactions/waitForTransaction.ts
 async function waitForTransaction({
-  chainId: chainId2,
-  confirmations,
+  chainId,
+  confirmations = 1,
   hash,
-  timeout,
-  wait: wait_
+  onSpeedUp,
+  timeout = 0
 }) {
-  let promise;
-  if (hash) {
-    const provider = getProvider({ chainId: chainId2 });
-    promise = provider.waitForTransaction(hash, confirmations, timeout);
-  } else if (wait_)
-    promise = wait_(confirmations);
-  else
-    throw new Error("hash or wait is required");
-  return promise;
+  const provider = getProvider({ chainId });
+  const [blockNumber, transaction] = await Promise.all([
+    fetchBlockNumber(),
+    fetchTransaction({ hash })
+  ]);
+  let replaceable = null;
+  if (confirmations !== 0 && transaction?.to) {
+    replaceable = {
+      data: transaction.data,
+      from: transaction.from,
+      nonce: transaction.nonce,
+      startBlock: blockNumber,
+      to: transaction.to,
+      value: transaction.value
+    };
+  }
+  try {
+    const receipt = await provider._waitForTransaction(
+      hash,
+      confirmations,
+      timeout,
+      replaceable
+    );
+    if (receipt.status === 0) {
+      const code = await provider.call(receipt, receipt.blockNumber);
+      const reason = toUtf8String(`0x${code.substring(138)}`);
+      throw new Error(reason);
+    }
+    return receipt;
+  } catch (err) {
+    if (err?.reason === "repriced") {
+      onSpeedUp?.(err.replacement);
+      return waitForTransaction({
+        hash: err.replacement?.hash,
+        confirmations,
+        timeout
+      });
+    }
+    throw err;
+  }
 }
 
 // src/actions/contracts/writeContract.ts
 async function writeContract({
   address,
   args,
-  chainId: chainId2,
+  chainId,
   abi,
   functionName,
   mode,
@@ -3009,8 +3060,8 @@ async function writeContract({
   const signer = await fetchSigner();
   if (!signer)
     throw new ConnectorNotFoundError();
-  if (chainId2)
-    assertActiveChain({ chainId: chainId2, signer });
+  if (chainId)
+    assertActiveChain({ chainId, signer });
   if (mode === "prepared") {
     if (!request_)
       throw new Error("`request` is required");
@@ -3018,7 +3069,7 @@ async function writeContract({
   const request = mode === "recklesslyUnprepared" ? (await prepareWriteContract({
     address,
     args,
-    chainId: chainId2,
+    chainId,
     abi,
     functionName,
     overrides
@@ -3033,15 +3084,15 @@ async function writeContract({
 // src/actions/accounts/fetchBalance.ts
 async function fetchBalance({
   address,
-  chainId: chainId2,
+  chainId,
   formatUnits: unit,
   token
 }) {
   const client2 = getClient();
-  const provider = getProvider({ chainId: chainId2 });
+  const provider = getProvider({ chainId });
   if (token) {
     const fetchContractBalance = async ({ abi }) => {
-      const erc20Config = { abi, address: token, chainId: chainId2 };
+      const erc20Config = { abi, address: token, chainId };
       const [value2, decimals, symbol] = await readContracts({
         allowFailure: false,
         contracts: [
@@ -3056,7 +3107,7 @@ async function fetchBalance({
       });
       return {
         decimals,
-        formatted: formatUnits2(value2 ?? "0", unit ?? decimals),
+        formatted: formatUnits3(value2 ?? "0", unit ?? decimals),
         symbol,
         value: value2
       };
@@ -3078,21 +3129,21 @@ async function fetchBalance({
   }
   const chains = [...client2.provider.chains || [], ...client2.chains ?? []];
   const value = await provider.getBalance(address);
-  const chain2 = chains.find((x) => x.id === provider.network.chainId);
+  const chain = chains.find((x) => x.id === provider.network.chainId);
   return {
-    decimals: chain2?.nativeCurrency?.decimals ?? 18,
-    formatted: formatUnits2(value ?? "0", unit ?? "ether"),
-    symbol: chain2?.nativeCurrency?.symbol ?? "ETH",
+    decimals: chain?.nativeCurrency.decimals ?? 18,
+    formatted: formatUnits3(value ?? "0", unit ?? "ether"),
+    symbol: chain?.nativeCurrency.symbol ?? "ETH",
     value
   };
 }
 
 // src/actions/accounts/fetchSigner.ts
 async function fetchSigner({
-  chainId: chainId2
+  chainId
 } = {}) {
   const client2 = getClient();
-  const signer = await client2.connector?.getSigner?.({ chainId: chainId2 }) || null;
+  const signer = await client2.connector?.getSigner?.({ chainId }) || null;
   return signer;
 }
 
@@ -3146,21 +3197,24 @@ function getAccount() {
 // src/actions/accounts/getNetwork.ts
 function getNetwork() {
   const client2 = getClient();
-  const chainId2 = client2.data?.chain?.id;
+  const chainId = client2.data?.chain?.id;
   const activeChains = client2.chains ?? [];
   const activeChain = [...client2.provider.chains || [], ...activeChains].find(
-    (x) => x.id === chainId2
+    (x) => x.id === chainId
   ) ?? {
-    id: chainId2,
-    name: `Chain ${chainId2}`,
-    network: `${chainId2}`,
-    rpcUrls: { default: "" }
+    id: chainId,
+    name: `Chain ${chainId}`,
+    network: `${chainId}`,
+    nativeCurrency: { name: "Ether", decimals: 18, symbol: "ETH" },
+    rpcUrls: {
+      default: { http: [""] }
+    }
   };
   return {
-    chain: chainId2 ? {
+    chain: chainId ? {
       ...activeChain,
       ...client2.data?.chain,
-      id: chainId2
+      id: chainId
     } : void 0,
     chains: activeChains
   };
@@ -3192,9 +3246,9 @@ async function signTypedData({
   if (!signer)
     throw new ConnectorNotFoundError();
   const { chainId: chainId_ } = domain;
-  const chainId2 = chainId_ ? normalizeChainId(chainId_) : void 0;
-  if (chainId2)
-    assertActiveChain({ chainId: chainId2, signer });
+  const chainId = chainId_ ? normalizeChainId(chainId_) : void 0;
+  if (chainId)
+    assertActiveChain({ chainId, signer });
   return signer._signTypedData(
     domain,
     types,
@@ -3204,7 +3258,7 @@ async function signTypedData({
 
 // src/actions/accounts/switchNetwork.ts
 async function switchNetwork({
-  chainId: chainId2
+  chainId
 }) {
   const { connector } = getClient();
   if (!connector)
@@ -3213,7 +3267,7 @@ async function switchNetwork({
     throw new SwitchChainNotSupportedError({
       connector
     });
-  return connector.switchChain(chainId2);
+  return connector.switchChain(chainId);
 }
 
 // src/actions/accounts/watchAccount.ts
@@ -3252,9 +3306,9 @@ function watchNetwork(callback, { selector = (x) => x } = {}) {
 
 // src/actions/accounts/watchSigner.ts
 import shallow5 from "zustand/shallow";
-function watchSigner({ chainId: chainId2 }, callback) {
+function watchSigner({ chainId }, callback) {
   const client2 = getClient();
-  const handleChange = async () => callback(await fetchSigner({ chainId: chainId2 }));
+  const handleChange = async () => callback(await fetchSigner({ chainId }));
   const unsubscribe = client2.subscribe(
     ({ data, connector }) => ({
       account: data?.account,
@@ -3269,42 +3323,28 @@ function watchSigner({ chainId: chainId2 }, callback) {
   return unsubscribe;
 }
 
-// src/actions/network-status/fetchFeeData.ts
-import { formatUnits as formatUnits3 } from "ethers/lib/utils.js";
-async function fetchFeeData({
-  chainId: chainId2,
-  formatUnits: units2 = "wei"
-} = {}) {
-  const provider = getProvider({ chainId: chainId2 });
-  const feeData = await provider.getFeeData();
-  const formatted = {
-    gasPrice: feeData.gasPrice ? formatUnits3(feeData.gasPrice, units2) : null,
-    maxFeePerGas: feeData.maxFeePerGas ? formatUnits3(feeData.maxFeePerGas, units2) : null,
-    maxPriorityFeePerGas: feeData.maxPriorityFeePerGas ? formatUnits3(feeData.maxPriorityFeePerGas, units2) : null
-  };
-  return { ...feeData, formatted };
-}
-
 // src/errors.ts
 var RpcError = class extends Error {
-  constructor(code, message, internal, data) {
+  constructor(message, options) {
+    const { cause, code, data } = options;
     if (!Number.isInteger(code))
       throw new Error('"code" must be an integer.');
     if (!message || typeof message !== "string")
       throw new Error('"message" must be a nonempty string.');
     super(message);
+    this.cause = cause;
     this.code = code;
     this.data = data;
-    this.internal = internal;
   }
 };
 var ProviderRpcError = class extends RpcError {
-  constructor(code, message, internal, data) {
+  constructor(message, options) {
+    const { cause, code, data } = options;
     if (!(Number.isInteger(code) && code >= 1e3 && code <= 4999))
       throw new Error(
         '"code" must be an integer such that: 1000 <= code <= 4999'
       );
-    super(code, message, internal, data);
+    super(message, { cause, code, data });
   }
 };
 var AddChainError = class extends Error {
@@ -3315,9 +3355,9 @@ var AddChainError = class extends Error {
   }
 };
 var ChainDoesNotSupportMulticallError = class extends Error {
-  constructor({ blockNumber, chain: chain2 }) {
+  constructor({ blockNumber, chain }) {
     super(
-      `Chain "${chain2.name}" does not support multicall${blockNumber ? ` on block ${blockNumber}` : ""}.`
+      `Chain "${chain.name}" does not support multicall${blockNumber ? ` on block ${blockNumber}` : ""}.`
     );
     this.name = "ChainDoesNotSupportMulticall";
   }
@@ -3335,10 +3375,10 @@ var ChainMismatchError = class extends Error {
 };
 var ChainNotConfiguredError = class extends Error {
   constructor({
-    chainId: chainId2,
+    chainId,
     connectorId
   }) {
-    super(`Chain "${chainId2}" not configured for connector "${connectorId}".`);
+    super(`Chain "${chainId}" not configured for connector "${connectorId}".`);
     this.name = "ChainNotConfigured";
   }
 };
@@ -3359,12 +3399,12 @@ var ConnectorNotFoundError = class extends Error {
 var ContractMethodDoesNotExistError = class extends Error {
   constructor({
     address,
-    chainId: chainId2,
+    chainId,
     functionName
   }) {
     const { chains, network } = getProvider();
-    const chain2 = chains?.find(({ id }) => id === (chainId2 || network.chainId));
-    const blockExplorer = chain2?.blockExplorers?.default;
+    const chain = chains?.find(({ id }) => id === (chainId || network.chainId));
+    const blockExplorer = chain?.blockExplorers?.default;
     super(
       [
         `Function "${functionName}" on contract "${address}" does not exist.`,
@@ -3381,7 +3421,7 @@ var ContractMethodNoResultError = class extends Error {
   constructor({
     address,
     args,
-    chainId: chainId2,
+    chainId,
     functionName
   }) {
     super(
@@ -3397,7 +3437,7 @@ var ContractMethodNoResultError = class extends Error {
             address,
             abi: "...",
             functionName,
-            chainId: chainId2,
+            chainId,
             args
           },
           null,
@@ -3412,7 +3452,7 @@ var ContractMethodRevertedError = class extends Error {
   constructor({
     address,
     args,
-    chainId: chainId2,
+    chainId,
     functionName,
     errorMessage
   }) {
@@ -3426,7 +3466,7 @@ var ContractMethodRevertedError = class extends Error {
             address,
             abi: "...",
             functionName,
-            chainId: chainId2,
+            chainId,
             args
           },
           null,
@@ -3443,7 +3483,7 @@ var ContractResultDecodeError = class extends Error {
   constructor({
     address,
     args,
-    chainId: chainId2,
+    chainId,
     functionName,
     errorMessage
   }) {
@@ -3457,7 +3497,7 @@ var ContractResultDecodeError = class extends Error {
             address,
             abi: "...",
             functionName,
-            chainId: chainId2,
+            chainId,
             args
           },
           null,
@@ -3493,14 +3533,14 @@ var ProviderChainsNotFound = class extends Error {
   }
 };
 var ResourceUnavailableError = class extends RpcError {
-  constructor(error) {
-    super(-32002, "Resource unavailable", error);
+  constructor(cause) {
+    super("Resource unavailable", { cause, code: -32002 });
     this.name = "ResourceUnavailable";
   }
 };
 var SwitchChainError = class extends ProviderRpcError {
-  constructor(error) {
-    super(4902, "Error switching chain", error);
+  constructor(cause) {
+    super("Error switching chain", { cause, code: 4902 });
     this.name = "SwitchChainError";
   }
 };
@@ -3511,8 +3551,8 @@ var SwitchChainNotSupportedError = class extends Error {
   }
 };
 var UserRejectedRequestError = class extends ProviderRpcError {
-  constructor(error) {
-    super(4001, "User rejected request", error);
+  constructor(cause) {
+    super("User rejected request", { cause, code: 4001 });
     this.name = "UserRejectedRequestError";
   }
 };
@@ -3543,10 +3583,6 @@ export {
   normalizeChainId,
   parseContractResult,
   serialize,
-  erc20ABI,
-  erc721ABI,
-  erc4626ABI,
-  units,
   Connector,
   InjectedConnector,
   noopStorage,
@@ -3556,6 +3592,10 @@ export {
   getClient,
   connect,
   disconnect,
+  erc20ABI,
+  erc721ABI,
+  erc4626ABI,
+  units,
   fetchToken,
   getContract,
   prepareWriteContract,
@@ -3579,6 +3619,7 @@ export {
   fetchEnsResolver,
   prepareSendTransaction,
   sendTransaction,
+  fetchFeeData,
   waitForTransaction,
   writeContract,
   fetchBalance,
@@ -3590,6 +3631,5 @@ export {
   switchNetwork,
   watchAccount,
   watchNetwork,
-  watchSigner,
-  fetchFeeData
+  watchSigner
 };