@wagmi/core 0.10.10 → 1.0.0-next.1

package/dist/{chunk-VQG3VKOR.js → chunk-LF3Y5HFO.js}

@@ -9,23 +9,23 @@ import {
 } from "./chunk-MQXBDTVK.js";
 
 // src/utils/configureChains.ts
-import { providers } from "ethers";
-function configureChains(defaultChains, providers2, {
-  minQuorum = 1,
+import { createPublicClient, fallback, http, webSocket } from "viem";
+function configureChains(defaultChains, providers, {
+  batch = { multicall: { wait: 32 } },
   pollingInterval = 4e3,
-  targetQuorum = 1,
+  rank,
+  retryCount,
+  retryDelay,
   stallTimeout
 } = {}) {
   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_ = {};
+  const httpUrls = {};
+  const wsUrls = {};
   for (const chain of defaultChains) {
     let configExists = false;
-    for (const provider of providers2) {
+    for (const provider of providers) {
       const apiConfig = provider(chain);
       if (!apiConfig)
         continue;
@@ -33,14 +33,14 @@ function configureChains(defaultChains, providers2, {
       if (!chains.some(({ id }) => id === chain.id)) {
         chains = [...chains, apiConfig.chain];
       }
-      providers_[chain.id] = [
-        ...providers_[chain.id] || [],
-        apiConfig.provider
+      httpUrls[chain.id] = [
+        ...httpUrls[chain.id] || [],
+        ...apiConfig.rpcUrls.http
       ];
-      if (apiConfig.webSocketProvider) {
-        webSocketProviders_[chain.id] = [
-          ...webSocketProviders_[chain.id] || [],
-          apiConfig.webSocketProvider
+      if (apiConfig.rpcUrls.webSocket) {
+        wsUrls[chain.id] = [
+          ...wsUrls[chain.id] || [],
+          ...apiConfig.rpcUrls.webSocket
         ];
       }
     }
@@ -57,121 +57,89 @@ function configureChains(defaultChains, providers2, {
   }
   return {
     chains,
-    provider: ({ chainId }) => {
+    publicClient: ({ chainId }) => {
       const activeChain = chains.find((x) => x.id === chainId) ?? defaultChains[0];
-      const chainProviders = providers_[activeChain.id];
-      if (!chainProviders || !chainProviders[0])
+      const chainHttpUrls = httpUrls[activeChain.id];
+      if (!chainHttpUrls || !chainHttpUrls[0])
         throw new Error(`No providers configured for chain "${activeChain.id}"`);
-      let provider;
-      if (chainProviders.length === 1) {
-        provider = chainProviders[0]();
-      } else {
-        provider = fallbackProvider(targetQuorum, minQuorum, chainProviders, {
-          stallTimeout
-        });
-      }
-      if (activeChain.id === 42220) {
-        provider.formatter.formats.block = {
-          ...provider.formatter.formats.block,
-          difficulty: () => 0,
-          gasLimit: () => 0
-        };
-      }
-      return Object.assign(provider, {
-        chains,
+      const publicClient = createPublicClient({
+        batch,
+        chain: activeChain,
+        transport: fallback(
+          chainHttpUrls.map((url) => http(url, { timeout: stallTimeout })),
+          { rank, retryCount, retryDelay }
+        ),
         pollingInterval
       });
+      return Object.assign(publicClient, {
+        chains
+      });
     },
-    webSocketProvider: ({ chainId }) => {
+    webSocketPublicClient: ({ chainId }) => {
       const activeChain = chains.find((x) => x.id === chainId) ?? defaultChains[0];
-      const chainWebSocketProviders = webSocketProviders_[activeChain.id];
-      if (!chainWebSocketProviders)
+      const chainWsUrls = wsUrls[activeChain.id];
+      if (!chainWsUrls || !chainWsUrls[0])
         return void 0;
-      const provider = chainWebSocketProviders[0]?.();
-      if (provider && activeChain.id === 42220) {
-        provider.formatter.formats.block = {
-          ...provider.formatter.formats.block,
-          difficulty: () => 0,
-          gasLimit: () => 0
-        };
-      }
-      return Object.assign(provider || {}, {
+      const publicClient = createPublicClient({
+        batch,
+        chain: activeChain,
+        transport: fallback(
+          chainWsUrls.map((url) => webSocket(url, { timeout: stallTimeout })),
+          { rank, retryCount, retryDelay }
+        ),
+        pollingInterval
+      });
+      return Object.assign(publicClient, {
         chains
       });
     }
   };
 }
-function fallbackProvider(targetQuorum, minQuorum, providers_, { stallTimeout }) {
-  try {
-    return new providers.FallbackProvider(
-      providers_.map((chainProvider, index) => {
-        const provider = chainProvider();
-        return {
-          provider,
-          priority: provider.priority ?? index,
-          stallTimeout: provider.stallTimeout ?? stallTimeout,
-          weight: provider.weight
-        };
-      }),
-      targetQuorum
+
+// src/errors.ts
+import { ConnectorNotFoundError } from "@wagmi/connectors";
+var ChainMismatchError = class extends Error {
+  constructor({
+    activeChain,
+    targetChain
+  }) {
+    super(
+      `Chain mismatch: Expected "${targetChain}", received "${activeChain}".`
     );
-  } catch (error) {
-    if (error?.message?.includes(
-      "quorum will always fail; larger than total weight"
-    )) {
-      if (targetQuorum === minQuorum)
-        throw error;
-      return fallbackProvider(targetQuorum - 1, minQuorum, providers_, {
-        stallTimeout
-      });
-    }
-    throw error;
+    this.name = "ChainMismatchError";
   }
-}
-
-// src/client.ts
-import { persist, subscribeWithSelector } from "zustand/middleware";
-import { createStore } from "zustand/vanilla";
-
-// src/utils/assertActiveChain.ts
-function assertActiveChain({
-  chainId,
-  signer
-}) {
-  const { chain: activeChain, chains } = getNetwork();
-  const activeChainId = activeChain?.id;
-  if (activeChainId && chainId !== activeChainId) {
-    throw new ChainMismatchError({
-      activeChain: chains.find((x) => x.id === activeChainId)?.name ?? `Chain ${activeChainId}`,
-      targetChain: chains.find((x) => x.id === chainId)?.name ?? `Chain ${chainId}`
-    });
+};
+var ChainNotConfiguredError = class extends Error {
+  constructor({
+    chainId,
+    connectorId
+  }) {
+    super(
+      `Chain "${chainId}" not configured${connectorId ? ` for connector "${connectorId}"` : ""}.`
+    );
+    this.name = "ChainNotConfigured";
   }
-  if (signer) {
-    const signerChainId = signer.provider?.network?.chainId;
-    if (signerChainId && chainId !== signerChainId) {
-      const connector = getClient().connector;
-      throw new ChainNotConfiguredError({
-        chainId,
-        connectorId: connector?.id ?? "unknown"
-      });
-    }
+};
+var ConnectorAlreadyConnectedError = class extends Error {
+  constructor() {
+    super(...arguments);
+    this.name = "ConnectorAlreadyConnectedError";
+    this.message = "Connector already connected";
   }
-}
-
-// src/utils/debounce.ts
-function debounce(fn, waitTime = 0) {
-  let timeout;
-  return function(...args) {
-    if (!waitTime)
-      return fn(...args);
-    if (timeout)
-      clearTimeout(timeout);
-    timeout = setTimeout(function() {
-      timeout = null;
-      fn(...args);
-    }, waitTime);
-  };
-}
+};
+var ClientChainsNotFound = class extends Error {
+  constructor() {
+    super(...arguments);
+    this.name = "ClientChainsNotFound";
+    this.message = "No chains were found on the wagmi Client. Some functions that require a chain may not work.";
+  }
+};
+var SwitchChainNotSupportedError = class extends Error {
+  constructor({ connector }) {
+    super(`"${connector.name}" does not support programmatic chain switching.`);
+    this.name = "SwitchChainNotSupportedError";
+  }
+};
 
 // src/utils/deepEqual.ts
 function deepEqual(a, b) {
@@ -213,7 +181,6 @@ function deepEqual(a, b) {
 }
 
 // src/utils/deserialize.ts
-import { BigNumber } from "ethers";
 var findAndReplace = (cacheRef, {
   find,
   replace
@@ -240,136 +207,51 @@ var findAndReplace = (cacheRef, {
 };
 function deserialize(cachedString) {
   const cache = JSON.parse(cachedString);
-  const deserializedCacheWithBigNumbers = findAndReplace(cache, {
-    find: (data) => data.type === "BigNumber",
-    replace: (data) => BigNumber.from(data.hex)
+  const deserializedCacheWithBigInts = findAndReplace(cache, {
+    find: (data) => typeof data === "string" && data.startsWith("#bigint."),
+    replace: (data) => BigInt(data.replace("#bigint.", ""))
   });
-  return deserializedCacheWithBigNumbers;
-}
-
-// src/utils/normalizeFunctionName.ts
-import { BigNumber as BigNumber2 } from "ethers";
-import { FunctionFragment, isAddress } from "ethers/lib/utils.js";
-function normalizeFunctionName({
-  contract,
-  functionName,
-  args = []
-}) {
-  if (functionName in contract.functions)
-    return functionName;
-  const argsLength = args?.length ?? 0;
-  const overloadFunctions = Object.keys(contract.functions).filter((x) => x.startsWith(`${functionName}(`)).map((x) => ({ name: x, fragment: FunctionFragment.fromString(x) })).filter((x) => argsLength === x.fragment.inputs.length);
-  for (const overloadFunction of overloadFunctions) {
-    const matched = args.every((arg, index) => {
-      const abiParameter = overloadFunction.fragment.inputs[index];
-      return isArgOfType(arg, abiParameter);
-    });
-    if (matched)
-      return overloadFunction.name;
-  }
-  return functionName;
-}
-function isArgOfType(arg, abiParameter) {
-  const argType = typeof arg;
-  const abiParameterType = abiParameter.type;
-  switch (abiParameterType) {
-    case "address":
-      return isAddress(arg);
-    case "bool":
-      return argType === "boolean";
-    case "function":
-      return argType === "string";
-    case "string":
-      return argType === "string";
-    default: {
-      if (abiParameterType === "tuple" && "components" in abiParameter)
-        return Object.values(abiParameter.components).every(
-          (component, index) => {
-            return isArgOfType(
-              Object.values(arg)[index],
-              component
-            );
-          }
-        );
-      if (/^u?int(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/.test(
-        abiParameterType
-      ))
-        return argType === "number" || argType === "bigint" || BigNumber2.isBigNumber(arg);
-      if (/^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/.test(abiParameterType))
-        return argType === "string" || arg instanceof Uint8Array;
-      if (/[a-z]+[1-9]{0,3}(\[[0-9]{0,}\])+$/.test(abiParameterType)) {
-        return Array.isArray(arg) && arg.every(
-          (x) => isArgOfType(x, {
-            ...abiParameter,
-            type: abiParameterType.replace(/(\[[0-9]{0,}\])$/, "")
-          })
-        );
-      }
-      return false;
-    }
-  }
+  return deserializedCacheWithBigInts;
 }
 
-// src/utils/logger.ts
-function logWarn(message) {
-  getClient()?.config.logger?.warn?.(message);
-}
-
-// src/utils/minimizeContractInterface.ts
-import { Contract } from "ethers";
-import { FormatTypes } from "ethers/lib/utils.js";
-function minimizeContractInterface(config) {
-  try {
-    const minimizedAbi = config.abi.filter(
-      (x) => x.type === "function" && x.name === config.functionName
-    );
-    if (minimizedAbi.length === 0)
-      throw new Error("Invalid ABI");
-    return minimizedAbi;
-  } catch (error) {
-    const abi = Contract.getInterface(config.abi).format(
-      FormatTypes.full
-    );
-    const minimizedInterface = Array.isArray(abi) ? abi : [abi];
-    return minimizedInterface.filter((i) => i.includes(config.functionName));
-  }
+// src/utils/getParameters.ts
+function getCallParameters(args) {
+  return {
+    accessList: args.accessList,
+    blockNumber: args.blockNumber,
+    blockTag: args.blockTag,
+    data: args.data,
+    gas: args.gas,
+    gasPrice: args.gasPrice,
+    maxFeePerGas: args.maxFeePerGas,
+    maxPriorityFeePerGas: args.maxPriorityFeePerGas,
+    nonce: args.nonce,
+    to: args.to,
+    value: args.value
+  };
 }
-
-// src/utils/normalizeChainId.ts
-function normalizeChainId(chainId) {
-  if (typeof chainId === "string")
-    return Number.parseInt(
-      chainId,
-      chainId.trim().substring(0, 2) === "0x" ? 16 : 10
-    );
-  if (typeof chainId === "bigint")
-    return Number(chainId);
-  return chainId;
+function getSendTransactionParameters(args) {
+  return {
+    accessList: args.accessList,
+    data: args.data,
+    gas: args.gas,
+    gasPrice: args.gasPrice,
+    maxFeePerGas: args.maxFeePerGas,
+    maxPriorityFeePerGas: args.maxPriorityFeePerGas,
+    nonce: args.nonce,
+    to: args.to,
+    value: args.value
+  };
 }
 
-// src/utils/parseContractResult.ts
-import { Contract as Contract2 } from "ethers";
-function isPlainArray(value) {
-  return Array.isArray(value) && Object.keys(value).length === value.length;
-}
-function parseContractResult({
-  abi,
-  data,
-  functionName
-}) {
-  if (data && isPlainArray(data)) {
-    const iface = Contract2.getInterface(abi);
-    const fragment = iface.getFunction(functionName);
-    const isTuple = (fragment.outputs?.length || 0) > 1;
-    const data_ = isTuple ? data : [data];
-    const encodedResult = iface.encodeFunctionResult(functionName, data_);
-    const decodedResult = iface.decodeFunctionResult(
-      functionName,
-      encodedResult
-    );
-    return isTuple ? decodedResult : decodedResult[0];
-  }
-  return data;
+// src/utils/getUnit.ts
+import { weiUnits } from "viem";
+function getUnit(unit) {
+  if (typeof unit === "number")
+    return unit;
+  if (unit === "wei")
+    return 0;
+  return Math.abs(weiUnits[unit]);
 }
 
 // src/utils/serialize.ts
@@ -421,11 +303,18 @@ function createReplacer(replacer, circularReplacer) {
 function serialize(value, replacer, indent, circularReplacer) {
   return JSON.stringify(
     value,
-    createReplacer(replacer, circularReplacer),
+    createReplacer((key, value_) => {
+      const value2 = typeof value_ === "bigint" ? `#bigint.${value_.toString()}` : value_;
+      return replacer?.(key, value2) || value2;
+    }, circularReplacer),
     indent ?? void 0
   );
 }
 
+// src/client.ts
+import { persist, subscribeWithSelector } from "zustand/middleware";
+import { createStore } from "zustand/vanilla";
+
 // src/storage.ts
 var noopStorage = {
   getItem: (_key) => "",
@@ -471,27 +360,27 @@ var Client = class {
   constructor({
     autoConnect = false,
     connectors = [new InjectedConnector()],
-    provider,
+    publicClient,
     storage = createStorage({
       storage: typeof window !== "undefined" ? window.localStorage : noopStorage
     }),
     logger = {
       warn: console.warn
     },
-    webSocketProvider
+    webSocketPublicClient
   }) {
     __privateAdd(this, _addEffects);
-    this.providers = /* @__PURE__ */ new Map();
-    this.webSocketProviders = /* @__PURE__ */ new Map();
+    this.publicClients = /* @__PURE__ */ new Map();
+    this.webSocketPublicClients = /* @__PURE__ */ new Map();
     __privateAdd(this, _isAutoConnecting, void 0);
     __privateAdd(this, _lastUsedConnector, void 0);
     this.config = {
       autoConnect,
       connectors,
       logger,
-      provider,
+      publicClient,
       storage,
-      webSocketProvider
+      webSocketPublicClient
     };
     let status = "disconnected";
     let chainId;
@@ -504,14 +393,16 @@ var Client = class {
       } catch (_error) {
       }
     }
+    const connectors_ = typeof connectors === "function" ? connectors() : connectors;
+    connectors_.forEach((connector) => connector.setStorage(storage));
     this.store = createStore(
       subscribeWithSelector(
         persist(
           () => ({
-            connectors: typeof connectors === "function" ? connectors() : connectors,
-            provider: this.getProvider({ chainId }),
+            connectors: connectors_,
+            publicClient: this.getPublicClient({ chainId }),
             status,
-            webSocketProvider: this.getWebSocketProvider({ chainId })
+            webSocketPublicClient: this.getWebSocketPublicClient({ chainId })
           }),
           {
             name: storeKey,
@@ -554,8 +445,8 @@ var Client = class {
   get lastUsedChainId() {
     return this.data?.chain?.id;
   }
-  get provider() {
-    return this.store.getState().provider;
+  get publicClient() {
+    return this.store.getState().publicClient;
   }
   get status() {
     return this.store.getState().status;
@@ -563,8 +454,8 @@ var Client = class {
   get subscribe() {
     return this.store.subscribe;
   }
-  get webSocketProvider() {
-    return this.store.getState().webSocketProvider;
+  get webSocketPublicClient() {
+    return this.store.getState().webSocketPublicClient;
   }
   setState(updater) {
     const newState = typeof updater === "function" ? updater(this.store.getState()) : updater;
@@ -625,27 +516,30 @@ var Client = class {
     __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_;
+  getPublicClient({ chainId } = {}) {
+    let publicClient_ = this.publicClients.get(-1);
+    if (publicClient_ && publicClient_?.chain.id === chainId)
+      return publicClient_;
+    publicClient_ = this.publicClients.get(chainId ?? -1);
+    if (publicClient_)
+      return publicClient_;
+    const { publicClient } = this.config;
+    publicClient_ = typeof publicClient === "function" ? publicClient({ chainId }) : publicClient;
+    this.publicClients.set(chainId ?? -1, publicClient_);
+    return publicClient_;
+  }
+  getWebSocketPublicClient({ chainId } = {}) {
+    let webSocketPublicClient_ = this.webSocketPublicClients.get(-1);
+    if (webSocketPublicClient_ && webSocketPublicClient_?.chain.id === chainId)
+      return webSocketPublicClient_;
+    webSocketPublicClient_ = this.webSocketPublicClients.get(chainId ?? -1);
+    if (webSocketPublicClient_)
+      return webSocketPublicClient_;
+    const { webSocketPublicClient } = this.config;
+    webSocketPublicClient_ = typeof webSocketPublicClient === "function" ? webSocketPublicClient({ chainId }) : webSocketPublicClient;
+    if (webSocketPublicClient_)
+      this.webSocketPublicClients.set(chainId ?? -1, webSocketPublicClient_);
+    return webSocketPublicClient_;
   }
   setLastUsedConnector(lastUsedConnector = null) {
     this.storage?.setItem("wallet", lastUsedConnector);
@@ -680,18 +574,17 @@ addEffects_fn = function() {
       connector.on?.("error", onError);
     }
   );
-  const { provider, webSocketProvider } = this.config;
-  const subscribeProvider = typeof provider === "function";
-  const subscribeWebSocketProvider = typeof webSocketProvider === "function";
-  if (subscribeProvider || subscribeWebSocketProvider)
+  const { publicClient, webSocketPublicClient } = this.config;
+  const subscribePublicClient = typeof publicClient === "function";
+  const subscribeWebSocketPublicClient = typeof webSocketPublicClient === "function";
+  if (subscribePublicClient || subscribeWebSocketPublicClient)
     this.store.subscribe(
       ({ data }) => data?.chain?.id,
       (chainId) => {
         this.setState((x) => ({
           ...x,
-          provider: this.getProvider({ bust: true, chainId }),
-          webSocketProvider: this.getWebSocketProvider({
-            bust: true,
+          publicClient: this.getPublicClient({ chainId }),
+          webSocketPublicClient: this.getWebSocketPublicClient({
             chainId
           })
         }));
@@ -714,10 +607,7 @@ function getClient() {
 }
 
 // src/actions/accounts/connect.ts
-async function connect({
-  chainId,
-  connector
-}) {
+async function connect({ chainId, connector }) {
   const client2 = getClient();
   const activeConnector = client2.connector;
   if (activeConnector && connector.id === activeConnector.id)
@@ -756,7 +646,12 @@ async function disconnect() {
 }
 
 // src/actions/accounts/fetchBalance.ts
-import { formatUnits as formatUnits3, parseBytes32String as parseBytes32String2 } from "ethers/lib/utils.js";
+import {
+  ContractFunctionExecutionError as ContractFunctionExecutionError3,
+  formatUnits as formatUnits2,
+  hexToString as hexToString2,
+  trim as trim2
+} from "viem";
 
 // src/constants/abis.ts
 var erc20ABI = [
@@ -1477,49 +1372,6 @@ var erc721ABI = [
     outputs: []
   }
 ];
-var multicallABI = [
-  {
-    inputs: [
-      {
-        components: [
-          {
-            name: "target",
-            type: "address"
-          },
-          {
-            name: "allowFailure",
-            type: "bool"
-          },
-          {
-            name: "callData",
-            type: "bytes"
-          }
-        ],
-        name: "calls",
-        type: "tuple[]"
-      }
-    ],
-    name: "aggregate3",
-    outputs: [
-      {
-        components: [
-          {
-            name: "success",
-            type: "bool"
-          },
-          {
-            name: "returnData",
-            type: "bytes"
-          }
-        ],
-        name: "returnData",
-        type: "tuple[]"
-      }
-    ],
-    stateMutability: "view",
-    type: "function"
-  }
-];
 var erc4626ABI = [
   {
     anonymous: false,
@@ -2029,23 +1881,17 @@ var erc4626ABI = [
   }
 ];
 
-// 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";
+import {
+  ContractFunctionExecutionError,
+  formatUnits,
+  hexToString,
+  trim
+} from "viem";
 async function fetchToken({
   address,
   chainId,
-  formatUnits: units2 = "ether"
+  formatUnits: unit = 18
 }) {
   async function fetchToken_({ abi }) {
     const erc20Config = { address, abi, chainId };
@@ -2064,7 +1910,7 @@ async function fetchToken({
       name,
       symbol,
       totalSupply: {
-        formatted: formatUnits(totalSupply, units2),
+        formatted: formatUnits(totalSupply, getUnit(unit)),
         value: totalSupply
       }
     };
@@ -2072,13 +1918,13 @@ async function fetchToken({
   try {
     return await fetchToken_({ abi: erc20ABI });
   } catch (err) {
-    if (err instanceof ContractResultDecodeError) {
+    if (err instanceof ContractFunctionExecutionError) {
       const { name, symbol, ...rest } = await fetchToken_({
         abi: erc20ABI_bytes32
       });
       return {
-        name: parseBytes32String(name),
-        symbol: parseBytes32String(symbol),
+        name: hexToString(trim(name, { dir: "right" })),
+        symbol: hexToString(trim(symbol, { dir: "right" })),
         ...rest
       };
     }
@@ -2086,289 +1932,208 @@ async function fetchToken({
   }
 }
 
-// src/actions/contracts/getContract.ts
-import { Contract as EthersContract } from "ethers";
-function getContract({
-  address,
-  abi,
-  signerOrProvider
-}) {
-  return new EthersContract(
-    address,
-    abi,
-    signerOrProvider
-  );
-}
-
-// src/actions/contracts/prepareWriteContract.ts
-async function prepareWriteContract({
-  abi,
-  address,
-  chainId,
-  functionName,
-  overrides,
-  signer: signer_,
-  ...config
-}) {
-  const signer = signer_ ?? await fetchSigner({ chainId });
-  if (!signer)
-    throw new ConnectorNotFoundError();
+// src/actions/viem/getPublicClient.ts
+function getPublicClient({ chainId } = {}) {
+  const client2 = getClient();
   if (chainId)
-    assertActiveChain({ chainId, signer });
-  const contract = getContract({
-    address,
-    abi,
-    signerOrProvider: signer
-  });
-  const args = config.args;
-  const normalizedFunctionName = normalizeFunctionName({
-    contract,
-    functionName,
-    args
-  });
-  const populateTransactionFn = contract.populateTransaction[normalizedFunctionName];
-  if (!populateTransactionFn)
-    throw new ContractMethodDoesNotExistError({
-      address,
-      functionName: normalizedFunctionName
-    });
-  const params = [...args ?? [], ...overrides ? [overrides] : []];
-  const unsignedTransaction = await populateTransactionFn(
-    ...params
-  );
-  const gasLimit = unsignedTransaction.gasLimit || await signer.estimateGas(unsignedTransaction);
-  const minimizedAbi = minimizeContractInterface({
-    abi,
-    functionName
-  });
-  return {
-    abi: minimizedAbi,
-    address,
-    chainId,
-    functionName,
-    mode: "prepared",
-    request: {
-      ...unsignedTransaction,
-      gasLimit
-    }
-  };
+    return client2.getPublicClient({ chainId }) || client2.publicClient;
+  return client2.publicClient;
 }
 
-// src/actions/providers/getProvider.ts
-function getProvider({
+// src/actions/viem/getWalletClient.ts
+async function getWalletClient({
   chainId
 } = {}) {
   const client2 = getClient();
-  if (chainId)
-    return client2.getProvider({ chainId }) || client2.provider;
-  return client2.provider;
+  const walletClient = await client2.connector?.getWalletClient?.({ chainId }) || null;
+  return walletClient;
 }
 
-// src/actions/providers/getWebSocketProvider.ts
-function getWebSocketProvider({
+// src/actions/viem/getWebSocketPublicClient.ts
+function getWebSocketPublicClient({
   chainId
 } = {}) {
   const client2 = getClient();
   if (chainId)
-    return client2.getWebSocketProvider({ chainId }) || client2.webSocketProvider;
-  return client2.webSocketProvider;
+    return client2.getWebSocketPublicClient({ chainId }) || client2.webSocketPublicClient;
+  return client2.webSocketPublicClient;
 }
 
-// src/actions/providers/watchProvider.ts
-function watchProvider(args, callback) {
+// src/actions/viem/watchPublicClient.ts
+function watchPublicClient(args, callback) {
   const client2 = getClient();
-  const handleChange = async () => callback(getProvider(args));
-  const unsubscribe = client2.subscribe(({ provider }) => provider, handleChange);
+  const handleChange = async () => callback(getPublicClient(args));
+  const unsubscribe = client2.subscribe(
+    ({ publicClient }) => publicClient,
+    handleChange
+  );
   return unsubscribe;
 }
 
-// src/actions/providers/watchWebSocketProvider.ts
-function watchWebSocketProvider(args, callback) {
+// src/actions/viem/watchWalletClient.ts
+import { shallow } from "zustand/shallow";
+function watchWalletClient({ chainId }, callback) {
   const client2 = getClient();
-  const handleChange = async () => callback(getWebSocketProvider(args));
+  const handleChange = async () => {
+    const walletClient = await getWalletClient({ chainId });
+    if (!getClient().connector)
+      return callback(null);
+    return callback(walletClient);
+  };
   const unsubscribe = client2.subscribe(
-    ({ webSocketProvider }) => webSocketProvider,
-    handleChange
+    ({ data, connector }) => ({
+      account: data?.account,
+      chainId: data?.chain?.id,
+      connector
+    }),
+    handleChange,
+    {
+      equalityFn: shallow
+    }
   );
   return unsubscribe;
 }
 
-// src/actions/contracts/multicall.ts
-async function multicall({
-  allowFailure = true,
-  chainId: chainIdOverride,
-  contracts,
-  overrides
-}) {
-  const provider = getProvider({ chainId: chainIdOverride });
-  if (!provider.chains?.[0])
-    throw new ProviderChainsNotFound();
-  const chainId = provider.network.chainId;
-  if (typeof chainIdOverride !== "undefined" && chainIdOverride !== chainId)
-    throw new ChainNotConfiguredError({ chainId: chainIdOverride });
-  const chain = provider.chains.find((chain2) => chain2.id === chainId);
-  if (!chain)
-    throw new ChainNotConfiguredError({ chainId });
-  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
-    });
-  const multicallContract = getContract({
-    address: chain.contracts.multicall3.address,
-    abi: multicallABI,
-    signerOrProvider: provider
-  });
-  const calls = contracts.map(
-    ({ address, abi, functionName, ...config }) => {
-      const { args } = config || {};
-      const contract = getContract({ address, abi });
-      const params2 = args ?? [];
-      const normalizedFunctionName = normalizeFunctionName({
-        contract,
-        functionName,
-        args
-      });
-      try {
-        const contractFunction = contract[normalizedFunctionName];
-        if (!contractFunction)
-          logWarn(
-            `"${normalizedFunctionName}" is not in the interface for contract "${address}"`
-          );
-        const callData = contract.interface.encodeFunctionData(
-          normalizedFunctionName,
-          params2
-        );
-        return {
-          target: address,
-          allowFailure,
-          callData
-        };
-      } catch (err) {
-        if (!allowFailure)
-          throw err;
-        return {
-          target: address,
-          allowFailure,
-          callData: "0x"
-        };
-      }
-    }
-  );
-  const params = [...[calls], ...overrides ? [overrides] : []];
-  const results = await multicallContract.aggregate3(
-    ...params
+// src/actions/viem/watchWebSocketPublicClient.ts
+function watchWebSocketPublicClient(args, callback) {
+  const client2 = getClient();
+  const handleChange = async () => callback(getWebSocketPublicClient(args));
+  const unsubscribe = client2.subscribe(
+    ({ webSocketPublicClient }) => webSocketPublicClient,
+    handleChange
   );
-  return results.map(({ returnData, success }, i) => {
-    const { address, abi, functionName, ...rest } = contracts[i];
-    const contract = getContract({
-      address,
-      abi
-    });
-    const args = rest.args;
-    const normalizedFunctionName = normalizeFunctionName({
-      contract,
-      functionName,
-      args
-    });
-    if (!success) {
-      let error;
-      try {
-        contract.interface.decodeFunctionResult(
-          normalizedFunctionName,
-          returnData
-        );
-      } catch (err) {
-        error = new ContractMethodRevertedError({
-          address,
-          args,
-          chainId: chain.id,
-          functionName: normalizedFunctionName,
-          errorMessage: err.message
-        });
-        if (!allowFailure)
-          throw error;
-        logWarn(error.message);
-      }
-      return null;
-    }
-    if (returnData === "0x") {
-      const error = new ContractMethodNoResultError({
-        address,
-        args,
-        chainId: chain.id,
-        functionName: normalizedFunctionName
-      });
-      if (!allowFailure)
-        throw error;
-      logWarn(error.message);
-      return null;
-    }
-    try {
-      const result = contract.interface.decodeFunctionResult(
-        normalizedFunctionName,
-        returnData
-      );
-      return Array.isArray(result) && result.length === 1 ? result[0] : result;
-    } catch (err) {
-      const error = new ContractResultDecodeError({
-        address,
-        args,
-        chainId: chain.id,
-        functionName: normalizedFunctionName,
-        errorMessage: err.message
-      });
-      if (!allowFailure)
-        throw error;
-      logWarn(error.message);
-      return null;
-    }
-  });
+  return unsubscribe;
 }
 
-// src/actions/contracts/readContract.ts
-async function readContract({
+// src/actions/contracts/prepareWriteContract.ts
+async function prepareWriteContract({
+  abi,
   address,
+  args,
   chainId,
-  abi,
   functionName,
-  overrides,
+  walletClient: walletClient_,
   ...config
 }) {
-  const provider = getProvider({ chainId });
-  const contract = getContract({
-    address,
+  const publicClient = getPublicClient({ chainId });
+  const walletClient = walletClient_ ?? await getWalletClient({ chainId });
+  if (!walletClient)
+    throw new ConnectorNotFoundError();
+  if (chainId)
+    assertActiveChain({ chainId, walletClient });
+  const {
+    accessList,
+    blockNumber,
+    blockTag,
+    gas,
+    gasPrice,
+    maxFeePerGas,
+    maxPriorityFeePerGas,
+    nonce,
+    value
+  } = getCallParameters(config);
+  const { result, request } = await publicClient.simulateContract({
     abi,
-    signerOrProvider: provider
-  });
-  const args = config.args;
-  const normalizedFunctionName = normalizeFunctionName({
-    contract,
+    address,
     functionName,
-    args
+    args,
+    account: walletClient.account,
+    accessList,
+    blockNumber,
+    blockTag,
+    gas,
+    gasPrice,
+    maxFeePerGas,
+    maxPriorityFeePerGas,
+    nonce,
+    value
+  });
+  const minimizedAbi = abi.filter(
+    (abiItem) => "name" in abiItem && abiItem.name === functionName
+  );
+  return {
+    mode: "prepared",
+    request: {
+      ...request,
+      abi: minimizedAbi,
+      chainId
+    },
+    result
+  };
+}
+
+// src/actions/contracts/getContract.ts
+import { getContract as getContract_ } from "viem";
+function getContract({
+  address,
+  abi,
+  chainId,
+  walletClient
+}) {
+  const publicClient = getPublicClient({ chainId });
+  return getContract_({
+    address,
+    abi,
+    publicClient,
+    walletClient
+  });
+}
+
+// src/actions/contracts/multicall.ts
+async function multicall({
+  chainId,
+  contracts,
+  blockNumber,
+  blockTag,
+  ...args
+}) {
+  const publicClient = getPublicClient({ chainId });
+  if (!publicClient.chains)
+    throw new ClientChainsNotFound();
+  if (chainId && publicClient.chain.id !== chainId)
+    throw new ChainNotConfiguredError({ chainId });
+  return publicClient.multicall({
+    allowFailure: args.allowFailure ?? true,
+    blockNumber,
+    blockTag,
+    contracts
+  });
+}
+
+// src/actions/contracts/readContract.ts
+async function readContract({
+  address,
+  chainId,
+  abi,
+  args,
+  functionName,
+  blockNumber,
+  blockTag
+}) {
+  const publicClient = getPublicClient({ chainId });
+  return publicClient.readContract({
+    abi,
+    address,
+    functionName,
+    args,
+    blockNumber,
+    blockTag
   });
-  const contractFunction = contract[normalizedFunctionName];
-  if (!contractFunction)
-    throw new ContractMethodDoesNotExistError({
-      address,
-      functionName: normalizedFunctionName
-    });
-  const params = [...args ?? [], ...overrides ? [overrides] : []];
-  return contractFunction?.(...params);
 }
 
 // src/actions/contracts/readContracts.ts
+import { ContractFunctionExecutionError as ContractFunctionExecutionError2 } from "viem";
 async function readContracts({
-  allowFailure = true,
   contracts,
-  overrides
+  blockNumber,
+  blockTag,
+  ...args
 }) {
+  const { allowFailure = true } = args;
   try {
-    const provider = getProvider();
+    const publicClient = getPublicClient();
     const contractsByChainId = contracts.reduce((contracts2, contract, index) => {
-      const chainId = contract.chainId ?? provider.network.chainId;
+      const chainId = contract.chainId ?? publicClient.chain.id;
       return {
         ...contracts2,
         [chainId]: [...contracts2[chainId] || [], { contract, index }]
@@ -2378,149 +2143,109 @@ async function readContracts({
       ([chainId, contracts2]) => multicall({
         allowFailure,
         chainId: parseInt(chainId),
-        contracts: contracts2.map(({ contract }) => contract),
-        overrides
+        contracts: contracts2.map(
+          ({ contract }) => contract
+        ),
+        blockNumber,
+        blockTag
       })
     );
-    let multicallResults;
-    if (allowFailure) {
-      multicallResults = (await Promise.allSettled(promises())).map((result) => {
-        if (result.status === "fulfilled")
-          return result.value;
-        if (result.reason instanceof ChainDoesNotSupportMulticallError) {
-          logWarn(result.reason.message);
-          throw result.reason;
-        }
-        return null;
-      }).flat();
-    } else {
-      multicallResults = (await Promise.all(promises())).flat();
-    }
-    const resultIndexes = Object.values(contractsByChainId).map((contracts2) => contracts2.map(({ index }) => index)).flat();
+    const multicallResults = (await Promise.all(promises())).flat();
+    const resultIndexes = Object.values(contractsByChainId).flatMap(
+      (contracts2) => contracts2.map(({ index }) => index)
+    );
     return multicallResults.reduce((results, result, index) => {
       if (results)
         results[resultIndexes[index]] = result;
       return results;
     }, []);
   } catch (err) {
-    if (err instanceof ContractResultDecodeError)
-      throw err;
-    if (err instanceof ContractMethodNoResultError)
-      throw err;
-    if (err instanceof ContractMethodRevertedError)
+    if (err instanceof ContractFunctionExecutionError2)
       throw err;
     const promises = () => contracts.map(
-      (contract) => readContract({ ...contract, overrides })
+      (contract) => readContract({ ...contract, blockNumber, blockTag })
     );
     if (allowFailure)
-      return (await Promise.allSettled(promises())).map((result, i) => {
+      return (await Promise.allSettled(promises())).map((result) => {
         if (result.status === "fulfilled")
-          return result.value;
-        const { address, args, chainId, functionName } = contracts[i];
-        const error = new ContractMethodRevertedError({
-          address,
-          functionName,
-          chainId: chainId ?? 1,
-          args,
-          errorMessage: result.reason
-        });
-        logWarn(error.message);
-        return null;
+          return { result: result.value, status: "success" };
+        return { error: result.reason, result: void 0, status: "failure" };
       });
     return await Promise.all(promises());
   }
 }
 
 // src/actions/contracts/watchContractEvent.ts
-import { shallow } from "zustand/shallow";
+import { shallow as shallow2 } from "zustand/shallow";
 function watchContractEvent({
   address,
   abi,
   chainId,
-  eventName,
-  once
+  eventName
 }, callback) {
-  const handler = (...event) => callback(...event);
-  let contract;
+  let unwatch;
   const watchEvent = async () => {
-    if (contract)
-      contract?.off(eventName, handler);
-    const signerOrProvider = getWebSocketProvider({ chainId }) || getProvider({ chainId });
-    contract = getContract({
+    if (unwatch)
+      unwatch();
+    const publicClient = getWebSocketPublicClient({ chainId }) || getPublicClient({ chainId });
+    unwatch = publicClient.watchContractEvent({
       address,
       abi,
-      signerOrProvider
+      eventName,
+      onLogs: callback
     });
-    if (once)
-      contract.once(eventName, handler);
-    else
-      contract.on(eventName, handler);
   };
   watchEvent();
   const client2 = getClient();
   const unsubscribe = client2.subscribe(
-    ({ provider, webSocketProvider }) => ({
-      provider,
-      webSocketProvider
+    ({ publicClient, webSocketPublicClient }) => ({
+      publicClient,
+      webSocketPublicClient
     }),
     watchEvent,
-    { equalityFn: shallow }
+    { equalityFn: shallow2 }
   );
   return () => {
-    contract?.off(eventName, handler);
+    unwatch?.();
     unsubscribe();
   };
 }
 
 // src/actions/network-status/watchBlockNumber.ts
-import { shallow as shallow2 } from "zustand/shallow";
-
-// src/actions/network-status/fetchBlockNumber.ts
-async function fetchBlockNumber({
-  chainId
-} = {}) {
-  const provider = getProvider({ chainId });
-  const blockNumber = await provider.getBlockNumber();
-  return blockNumber;
-}
-
-// src/actions/network-status/watchBlockNumber.ts
+import { shallow as shallow3 } from "zustand/shallow";
 function watchBlockNumber(args, callback) {
-  const debouncedCallback = debounce(callback, 1);
-  let previousProvider;
-  const createListener = (provider) => {
-    if (previousProvider) {
-      previousProvider?.off("block", debouncedCallback);
-    }
-    provider.on("block", debouncedCallback);
-    previousProvider = provider;
+  let unwatch;
+  const createListener = (publicClient) => {
+    if (unwatch)
+      unwatch();
+    unwatch = publicClient.watchBlockNumber({
+      onBlockNumber: callback,
+      emitOnBegin: true,
+      poll: true
+    });
   };
-  const provider_ = getWebSocketProvider({ chainId: args.chainId }) ?? getProvider({ chainId: args.chainId });
+  const publicClient_ = getWebSocketPublicClient({ chainId: args.chainId }) ?? getPublicClient({ chainId: args.chainId });
   if (args.listen)
-    createListener(provider_);
-  let active = true;
+    createListener(publicClient_);
   const client2 = getClient();
   const unsubscribe = client2.subscribe(
-    ({ provider, webSocketProvider }) => ({ provider, webSocketProvider }),
-    async ({ provider, webSocketProvider }) => {
-      const provider_2 = webSocketProvider ?? provider;
-      if (args.listen && !args.chainId && provider_2) {
-        createListener(provider_2);
-      }
-      const blockNumber = await fetchBlockNumber({ chainId: args.chainId });
-      if (!active)
-        return;
-      callback(blockNumber);
+    ({ publicClient, webSocketPublicClient }) => ({
+      publicClient,
+      webSocketPublicClient
+    }),
+    async ({ publicClient, webSocketPublicClient }) => {
+      const publicClient_2 = webSocketPublicClient ?? publicClient;
+      if (args.listen && !args.chainId && publicClient_2) {
+        createListener(publicClient_2);
+      }
     },
     {
-      equalityFn: shallow2
+      equalityFn: shallow3
     }
   );
   return () => {
-    active = false;
     unsubscribe();
-    provider_?.off("block", debouncedCallback);
-    previousProvider?.off("block", debouncedCallback);
+    unwatch?.();
   };
 }
 
@@ -2529,7 +2254,10 @@ function watchMulticall(config, callback) {
   const client2 = getClient();
   const handleChange = async () => callback(await multicall(config));
   const unwatch = config.listenToBlock ? watchBlockNumber({ listen: true }, handleChange) : void 0;
-  const unsubscribe = client2.subscribe(({ provider }) => provider, handleChange);
+  const unsubscribe = client2.subscribe(
+    ({ publicClient }) => publicClient,
+    handleChange
+  );
   return () => {
     unsubscribe();
     unwatch?.();
@@ -2541,7 +2269,10 @@ function watchReadContract(config, callback) {
   const client2 = getClient();
   const handleChange = async () => callback(await readContract(config));
   const unwatch = config.listenToBlock ? watchBlockNumber({ listen: true }, handleChange) : void 0;
-  const unsubscribe = client2.subscribe(({ provider }) => provider, handleChange);
+  const unsubscribe = client2.subscribe(
+    ({ publicClient }) => publicClient,
+    handleChange
+  );
   return () => {
     unsubscribe();
     unwatch?.();
@@ -2553,251 +2284,36 @@ function watchReadContracts(config, callback) {
   const client2 = getClient();
   const handleChange = async () => callback(await readContracts(config));
   const unwatch = config.listenToBlock ? watchBlockNumber({ listen: true }, handleChange) : void 0;
-  const unsubscribe = client2.subscribe(({ provider }) => provider, handleChange);
-  return () => {
-    unsubscribe();
-    unwatch?.();
-  };
-}
-
-// src/actions/transactions/fetchTransaction.ts
-async function fetchTransaction({
-  chainId,
-  hash
-}) {
-  const provider = getProvider({ chainId });
-  return provider.getTransaction(hash);
-}
-
-// src/actions/transactions/prepareSendTransaction.ts
-import { isAddress as isAddress2 } from "ethers/lib/utils.js";
-
-// src/actions/ens/fetchEnsAddress.ts
-import { getAddress } from "ethers/lib/utils.js";
-async function fetchEnsAddress({
-  chainId,
-  name
-}) {
-  const provider = getProvider({ chainId });
-  const address = await provider.resolveName(name);
-  try {
-    return address ? getAddress(address) : null;
-  } catch (_error) {
-    return null;
-  }
-}
-
-// src/actions/ens/fetchEnsAvatar.ts
-async function fetchEnsAvatar({
-  address,
-  chainId
-}) {
-  const provider = getProvider({ chainId });
-  const avatar = await provider.getAvatar(address);
-  return avatar;
-}
-
-// src/actions/ens/fetchEnsName.ts
-import { getAddress as getAddress2 } from "ethers/lib/utils.js";
-async function fetchEnsName({
-  address,
-  chainId
-}) {
-  const provider = getProvider({ chainId });
-  return provider.lookupAddress(getAddress2(address));
-}
-
-// src/actions/ens/fetchEnsResolver.ts
-async function fetchEnsResolver({
-  chainId,
-  name
-}) {
-  const provider = getProvider({ chainId });
-  const resolver = await provider.getResolver(name);
-  return resolver;
-}
-
-// src/actions/transactions/prepareSendTransaction.ts
-async function prepareSendTransaction({
-  chainId,
-  request,
-  signer: signer_
-}) {
-  const signer = signer_ ?? await fetchSigner({ chainId });
-  if (!signer)
-    throw new ConnectorNotFoundError();
-  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)
-  ]);
-  if (!to)
-    throw new Error("Could not resolve ENS name");
-  return {
-    ...chainId ? { chainId } : {},
-    request: { ...request, gasLimit, to },
-    mode: "prepared"
-  };
-}
-
-// src/actions/transactions/sendTransaction.ts
-async function sendTransaction({
-  chainId,
-  mode,
-  request
-}) {
-  const signer = await fetchSigner();
-  if (!signer)
-    throw new ConnectorNotFoundError();
-  if (mode === "prepared") {
-    if (!request.gasLimit)
-      throw new Error("`gasLimit` is required");
-    if (!request.to)
-      throw new Error("`to` is required");
-  }
-  if (chainId)
-    assertActiveChain({ chainId, signer });
-  try {
-    const uncheckedSigner = signer.connectUnchecked?.();
-    const { hash, wait } = await (uncheckedSigner ?? signer).sendTransaction(
-      request
-    );
-    return { hash, wait };
-  } catch (error) {
-    if (error.code === 4001 || error.code === "ACTION_REJECTED")
-      throw new UserRejectedRequestError(error);
-    throw error;
-  }
-}
-
-// 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,
-  confirmations = 1,
-  hash,
-  onSpeedUp,
-  timeout = 0
-}) {
-  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/transactions/watchPendingTransactions.ts
-import { shallow as shallow3 } from "zustand/shallow";
-function watchPendingTransactions(args, callback) {
-  let previousProvider;
-  const createListener = (provider) => {
-    if (previousProvider) {
-      previousProvider?.off("pending", callback);
-    }
-    provider.on("pending", callback);
-    previousProvider = provider;
-  };
-  const provider_ = getWebSocketProvider({ chainId: args.chainId }) ?? getProvider({ chainId: args.chainId });
-  createListener(provider_);
-  const client2 = getClient();
   const unsubscribe = client2.subscribe(
-    ({ provider, webSocketProvider }) => ({ provider, webSocketProvider }),
-    async ({ provider, webSocketProvider }) => {
-      const provider_2 = webSocketProvider ?? provider;
-      if (!args.chainId && provider_2) {
-        createListener(provider_2);
-      }
-    },
-    {
-      equalityFn: shallow3
-    }
+    ({ publicClient }) => publicClient,
+    handleChange
   );
   return () => {
     unsubscribe();
-    provider_?.off("pending", callback);
-    previousProvider?.off("pending", callback);
+    unwatch?.();
   };
 }
 
 // src/actions/contracts/writeContract.ts
 async function writeContract(config) {
-  const signer = await fetchSigner();
-  if (!signer)
+  const walletClient = await getWalletClient();
+  if (!walletClient)
     throw new ConnectorNotFoundError();
   if (config.chainId)
-    assertActiveChain({ chainId: config.chainId, signer });
+    assertActiveChain({ chainId: config.chainId, walletClient });
   let request;
   if (config.mode === "prepared") {
-    request = config.request;
+    request = config;
   } else {
-    request = (await prepareWriteContract({
-      address: config.address,
-      args: config.args,
-      chainId: config.chainId,
-      abi: config.abi,
-      functionName: config.functionName,
-      overrides: config.overrides
-    })).request;
+    const { chainId, mode, ...args } = config;
+    const res = await prepareWriteContract(args);
+    request = res.request;
   }
-  const transaction = await sendTransaction({
-    request,
-    mode: "prepared"
+  const hash = await walletClient.writeContract({
+    ...request,
+    chain: null
   });
-  return transaction;
+  return { hash };
 }
 
 // src/actions/accounts/fetchBalance.ts
@@ -2808,7 +2324,7 @@ async function fetchBalance({
   token
 }) {
   const client2 = getClient();
-  const provider = getProvider({ chainId });
+  const publicClient = getPublicClient({ chainId });
   if (token) {
     const fetchContractBalance = async ({ abi }) => {
       const erc20Config = { abi, address: token, chainId };
@@ -2826,7 +2342,7 @@ async function fetchBalance({
       });
       return {
         decimals,
-        formatted: formatUnits3(value2 ?? "0", unit ?? decimals),
+        formatted: formatUnits2(value2 ?? "0", getUnit(unit ?? decimals)),
         symbol,
         value: value2
       };
@@ -2834,38 +2350,32 @@ async function fetchBalance({
     try {
       return await fetchContractBalance({ abi: erc20ABI });
     } catch (err) {
-      if (err instanceof ContractResultDecodeError) {
+      if (err instanceof ContractFunctionExecutionError3) {
         const { symbol, ...rest } = await fetchContractBalance({
           abi: erc20ABI_bytes32
         });
         return {
-          symbol: parseBytes32String2(symbol),
+          symbol: hexToString2(trim2(symbol, { dir: "right" })),
           ...rest
         };
       }
       throw err;
     }
   }
-  const chains = [...client2.provider.chains || [], ...client2.chains ?? []];
-  const value = await provider.getBalance(address);
-  const chain = chains.find((x) => x.id === provider.network.chainId);
+  const chains = [
+    ...client2.publicClient.chains || [],
+    ...client2.chains ?? []
+  ];
+  const value = await publicClient.getBalance({ address });
+  const chain = chains.find((x) => x.id === publicClient.chain.id);
   return {
     decimals: chain?.nativeCurrency.decimals ?? 18,
-    formatted: formatUnits3(value ?? "0", unit ?? "ether"),
+    formatted: formatUnits2(value ?? "0", getUnit(unit ?? 18)),
     symbol: chain?.nativeCurrency.symbol ?? "ETH",
     value
   };
 }
 
-// src/actions/accounts/fetchSigner.ts
-async function fetchSigner({
-  chainId
-} = {}) {
-  const client2 = getClient();
-  const signer = await client2.connector?.getSigner?.({ chainId }) || null;
-  return signer;
-}
-
 // src/actions/accounts/getAccount.ts
 function getAccount() {
   const { data, connector, status } = getClient();
@@ -2918,9 +2428,10 @@ function getNetwork() {
   const client2 = getClient();
   const chainId = client2.data?.chain?.id;
   const activeChains = client2.chains ?? [];
-  const activeChain = [...client2.provider.chains || [], ...activeChains].find(
-    (x) => x.id === chainId
-  ) ?? {
+  const activeChain = [
+    ...client2.publicClient?.chains || [],
+    ...activeChains
+  ].find((x) => x.id === chainId) ?? {
     id: chainId,
     name: `Chain ${chainId}`,
     network: `${chainId}`,
@@ -2942,44 +2453,33 @@ function getNetwork() {
 
 // src/actions/accounts/signMessage.ts
 async function signMessage(args) {
-  try {
-    const signer = await fetchSigner();
-    if (!signer)
-      throw new ConnectorNotFoundError();
-    return await signer.signMessage(
-      args.message
-    );
-  } catch (error) {
-    if (error.code === 4001 || error.code === "ACTION_REJECTED")
-      throw new UserRejectedRequestError(error);
-    throw error;
-  }
+  const walletClient = await getWalletClient();
+  if (!walletClient)
+    throw new ConnectorNotFoundError();
+  return await walletClient.signMessage({
+    message: args.message
+  });
 }
 
 // src/actions/accounts/signTypedData.ts
 async function signTypedData({
   domain,
-  types,
-  value
+  message,
+  primaryType,
+  types
 }) {
-  const signer = await fetchSigner();
-  if (!signer)
+  const walletClient = await getWalletClient();
+  if (!walletClient)
     throw new ConnectorNotFoundError();
-  const { chainId: chainId_ } = domain;
-  const chainId = chainId_ ? normalizeChainId(chainId_) : void 0;
+  const { chainId } = domain;
   if (chainId)
-    assertActiveChain({ chainId, signer });
-  const types_ = Object.entries(types).filter(([key]) => key !== "EIP712Domain").reduce((types2, [key, attributes]) => {
-    types2[key] = attributes.filter((attr) => attr.type !== "EIP712Domain");
-    return types2;
-  }, {});
-  try {
-    return await signer._signTypedData(domain, types_, value);
-  } catch (error) {
-    if (error.code === 4001 || error.code === "ACTION_REJECTED")
-      throw new UserRejectedRequestError(error);
-    throw error;
-  }
+    assertActiveChain({ chainId, walletClient });
+  return walletClient.signTypedData({
+    message,
+    primaryType,
+    types,
+    domain
+  });
 }
 
 // src/actions/accounts/switchNetwork.ts
@@ -3030,291 +2530,264 @@ function watchNetwork(callback, { selector = (x) => x } = {}) {
   return unsubscribe;
 }
 
-// src/actions/accounts/watchSigner.ts
+// src/actions/ens/fetchEnsAddress.ts
+import { getAddress } from "viem";
+import { normalize } from "viem/ens";
+async function fetchEnsAddress({
+  chainId,
+  name
+}) {
+  const publicClient = getPublicClient({ chainId });
+  const address = await publicClient.getEnsAddress({
+    name: normalize(name)
+  });
+  try {
+    if (address === "0x0000000000000000000000000000000000000000")
+      return null;
+    return address ? getAddress(address) : null;
+  } catch (_error) {
+    return null;
+  }
+}
+
+// src/actions/ens/fetchEnsAvatar.ts
+import { normalize as normalize2 } from "viem/ens";
+async function fetchEnsAvatar({
+  name,
+  chainId
+}) {
+  const publicClient = getPublicClient({ chainId });
+  const avatar = await publicClient.getEnsAvatar({ name: normalize2(name) });
+  return avatar;
+}
+
+// src/actions/ens/fetchEnsName.ts
+import { getAddress as getAddress2 } from "viem";
+async function fetchEnsName({
+  address,
+  chainId
+}) {
+  const publicClient = getPublicClient({ chainId });
+  return publicClient.getEnsName({
+    address: getAddress2(address)
+  });
+}
+
+// src/actions/ens/fetchEnsResolver.ts
+import { normalize as normalize3 } from "viem/ens";
+async function fetchEnsResolver({
+  chainId,
+  name
+}) {
+  const publicClient = getPublicClient({ chainId });
+  const resolver = await publicClient.getEnsResolver({ name: normalize3(name) });
+  return resolver;
+}
+
+// src/actions/network-status/fetchBlockNumber.ts
+async function fetchBlockNumber({
+  chainId
+} = {}) {
+  const publicClient = getPublicClient({ chainId });
+  const blockNumber = await publicClient.getBlockNumber();
+  return blockNumber;
+}
+
+// src/actions/network-status/fetchFeeData.ts
+import { formatUnits as formatUnits3, parseGwei } from "viem";
+async function fetchFeeData({
+  chainId,
+  formatUnits: units = "gwei"
+} = {}) {
+  const publicClient = getPublicClient({ chainId });
+  const block = await publicClient.getBlock();
+  let gasPrice = null;
+  try {
+    gasPrice = await publicClient.getGasPrice();
+  } catch {
+  }
+  let lastBaseFeePerGas = null;
+  let maxFeePerGas = null;
+  let maxPriorityFeePerGas = null;
+  if (block?.baseFeePerGas) {
+    lastBaseFeePerGas = block.baseFeePerGas;
+    maxPriorityFeePerGas = parseGwei("1");
+    maxFeePerGas = block.baseFeePerGas * 2n + maxPriorityFeePerGas;
+  }
+  const unit = getUnit(units);
+  const formatted = {
+    gasPrice: gasPrice ? formatUnits3(gasPrice, unit) : null,
+    maxFeePerGas: maxFeePerGas ? formatUnits3(maxFeePerGas, unit) : null,
+    maxPriorityFeePerGas: maxPriorityFeePerGas ? formatUnits3(maxPriorityFeePerGas, unit) : null
+  };
+  return {
+    lastBaseFeePerGas,
+    gasPrice,
+    maxFeePerGas,
+    maxPriorityFeePerGas,
+    formatted
+  };
+}
+
+// src/actions/transactions/fetchTransaction.ts
+async function fetchTransaction({
+  chainId,
+  hash
+}) {
+  const publicClient = getPublicClient({ chainId });
+  return publicClient.getTransaction({ hash });
+}
+
+// src/actions/transactions/prepareSendTransaction.ts
+import { isAddress } from "viem";
+async function prepareSendTransaction({
+  chainId,
+  request,
+  walletClient: walletClient_
+}) {
+  const walletClient = walletClient_ ?? await getWalletClient({ chainId });
+  if (!walletClient)
+    throw new ConnectorNotFoundError();
+  if (chainId)
+    assertActiveChain({ chainId, walletClient });
+  const to = (request.to && !isAddress(request.to) ? await fetchEnsAddress({ name: request.to }) : request.to) || void 0;
+  if (to && !isAddress(to))
+    throw new Error("Invalid address");
+  return {
+    ...chainId ? { chainId } : {},
+    request: { ...request, to },
+    mode: "prepared"
+  };
+}
+
+// src/actions/transactions/sendTransaction.ts
+async function sendTransaction({
+  chainId,
+  mode,
+  request
+}) {
+  const walletClient = await getWalletClient();
+  if (!walletClient)
+    throw new ConnectorNotFoundError();
+  if (chainId)
+    assertActiveChain({ chainId, walletClient });
+  if (mode !== "prepared") {
+    const res = await prepareSendTransaction({ chainId, request });
+    request = res.request;
+  }
+  const hash = await walletClient.sendTransaction({
+    ...request,
+    chain: null
+  });
+  return { hash };
+}
+
+// src/actions/transactions/waitForTransaction.ts
+import { hexToString as hexToString3 } from "viem";
+async function waitForTransaction({
+  chainId,
+  confirmations = 1,
+  hash,
+  onReplaced,
+  timeout = 0
+}) {
+  const publicClient = getPublicClient({ chainId });
+  const receipt = await publicClient.waitForTransactionReceipt({
+    hash,
+    confirmations,
+    onReplaced,
+    timeout
+  });
+  if (receipt.status === "reverted") {
+    const txn = await publicClient.getTransaction({
+      hash: receipt.transactionHash
+    });
+    const code = await publicClient.call({
+      ...txn,
+      gasPrice: txn.type !== "eip1559" ? txn.gasPrice : void 0,
+      maxFeePerGas: txn.type === "eip1559" ? txn.maxFeePerGas : void 0,
+      maxPriorityFeePerGas: txn.type === "eip1559" ? txn.maxPriorityFeePerGas : void 0
+    });
+    const reason = hexToString3(`0x${code.substring(138)}`);
+    throw new Error(reason);
+  }
+  return receipt;
+}
+
+// src/actions/transactions/watchPendingTransactions.ts
 import { shallow as shallow6 } from "zustand/shallow";
-function watchSigner({ chainId }, callback) {
-  const client2 = getClient();
-  const handleChange = async () => {
-    const signer = await fetchSigner({ chainId });
-    if (!getClient().connector)
-      return callback(null);
-    return callback(signer);
+function watchPendingTransactions(args, callback) {
+  let unwatch;
+  const createListener = (publicClient) => {
+    if (unwatch)
+      unwatch();
+    unwatch = publicClient.watchPendingTransactions({
+      onTransactions: callback,
+      poll: true
+    });
   };
+  const publicClient_ = getWebSocketPublicClient({ chainId: args.chainId }) ?? getPublicClient({ chainId: args.chainId });
+  createListener(publicClient_);
+  const client2 = getClient();
   const unsubscribe = client2.subscribe(
-    ({ data, connector }) => ({
-      account: data?.account,
-      chainId: data?.chain?.id,
-      connector
+    ({ publicClient, webSocketPublicClient }) => ({
+      publicClient,
+      webSocketPublicClient
     }),
-    handleChange,
+    async ({ publicClient, webSocketPublicClient }) => {
+      const publicClient_2 = webSocketPublicClient ?? publicClient;
+      if (!args.chainId && publicClient_2) {
+        createListener(publicClient_2);
+      }
+    },
     {
       equalityFn: shallow6
     }
   );
-  return unsubscribe;
+  return () => {
+    unsubscribe();
+    unwatch?.();
+  };
 }
 
-// src/errors.ts
-var RpcError = class extends Error {
-  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;
-  }
-};
-var ProviderRpcError = class extends RpcError {
-  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(message, { cause, code, data });
-  }
-};
-var AddChainError = class extends Error {
-  constructor() {
-    super(...arguments);
-    this.name = "AddChainError";
-    this.message = "Error adding chain";
-  }
-};
-var ChainDoesNotSupportMulticallError = class extends Error {
-  constructor({ blockNumber, chain }) {
-    super(
-      `Chain "${chain.name}" does not support multicall${blockNumber ? ` on block ${blockNumber}` : ""}.`
-    );
-    this.name = "ChainDoesNotSupportMulticall";
-  }
-};
-var ChainMismatchError = class extends Error {
-  constructor({
-    activeChain,
-    targetChain
-  }) {
-    super(
-      `Chain mismatch: Expected "${targetChain}", received "${activeChain}".`
-    );
-    this.name = "ChainMismatchError";
-  }
-};
-var ChainNotConfiguredError = class extends Error {
-  constructor({
-    chainId,
-    connectorId
-  }) {
-    super(
-      `Chain "${chainId}" not configured${connectorId ? ` for connector "${connectorId}"` : ""}.`
-    );
-    this.name = "ChainNotConfigured";
-  }
-};
-var ConnectorAlreadyConnectedError = class extends Error {
-  constructor() {
-    super(...arguments);
-    this.name = "ConnectorAlreadyConnectedError";
-    this.message = "Connector already connected";
-  }
-};
-var ConnectorNotFoundError = class extends Error {
-  constructor() {
-    super(...arguments);
-    this.name = "ConnectorNotFoundError";
-    this.message = "Connector not found";
-  }
-};
-var ContractMethodDoesNotExistError = class extends Error {
-  constructor({
-    address,
-    chainId,
-    functionName
-  }) {
-    const { chains, network } = getProvider();
-    const chain = chains?.find(({ id }) => id === (chainId || network.chainId));
-    const blockExplorer = chain?.blockExplorers?.default;
-    super(
-      [
-        `Function "${functionName}" on contract "${address}" does not exist.`,
-        ...blockExplorer ? [
-          "",
-          `${blockExplorer?.name}: ${blockExplorer?.url}/address/${address}#readContract`
-        ] : []
-      ].join("\n")
-    );
-    this.name = "ContractMethodDoesNotExistError";
-  }
-};
-var ContractMethodNoResultError = class extends Error {
-  constructor({
-    address,
-    args,
-    chainId,
-    functionName
-  }) {
-    super(
-      [
-        "Contract read returned an empty response. This could be due to any of the following:",
-        `- The contract does not have the function "${functionName}",`,
-        "- The parameters passed to the contract function may be invalid, or",
-        "- The address is not a contract.",
-        "",
-        `Config:`,
-        JSON.stringify(
-          {
-            address,
-            abi: "...",
-            functionName,
-            chainId,
-            args
-          },
-          null,
-          2
-        )
-      ].join("\n")
-    );
-    this.name = "ContractMethodNoResultError";
-  }
-};
-var ContractMethodRevertedError = class extends Error {
-  constructor({
-    address,
-    args,
-    chainId,
-    functionName,
-    errorMessage
-  }) {
-    super(
-      [
-        "Contract method reverted with an error.",
-        "",
-        `Config:`,
-        JSON.stringify(
-          {
-            address,
-            abi: "...",
-            functionName,
-            chainId,
-            args
-          },
-          null,
-          2
-        ),
-        "",
-        `Details: ${errorMessage}`
-      ].join("\n")
-    );
-    this.name = "ContractMethodRevertedError";
-  }
-};
-var ContractResultDecodeError = class extends Error {
-  constructor({
-    address,
-    args,
-    chainId,
-    functionName,
-    errorMessage
-  }) {
-    super(
-      [
-        "Failed to decode contract function result.",
-        "",
-        `Config:`,
-        JSON.stringify(
-          {
-            address,
-            abi: "...",
-            functionName,
-            chainId,
-            args
-          },
-          null,
-          2
-        ),
-        "",
-        `Details: ${errorMessage}`
-      ].join("\n")
-    );
-    this.name = "ContractResultDecodeError";
-  }
-};
-var ProviderChainsNotFound = class extends Error {
-  constructor() {
-    super(...arguments);
-    this.name = "ProviderChainsNotFound";
-    this.message = [
-      "No chains were found on the wagmi provider. Some functions that require a chain may not work.",
-      "",
-      "It is recommended to add a list of chains to the provider in `createClient`.",
-      "",
-      "Example:",
-      "",
-      "```",
-      "import { getDefaultProvider } from 'ethers'",
-      "import { chain, createClient } from 'wagmi'",
-      "",
-      "createClient({",
-      "  provider: Object.assign(getDefaultProvider(), { chains: [chain.mainnet] })",
-      "})",
-      "```"
-    ].join("\n");
-  }
-};
-var ResourceUnavailableError = class extends RpcError {
-  constructor(cause) {
-    super("Resource unavailable", { cause, code: -32002 });
-    this.name = "ResourceUnavailable";
-  }
-};
-var SwitchChainError = class extends ProviderRpcError {
-  constructor(cause) {
-    super("Error switching chain", { cause, code: 4902 });
-    this.name = "SwitchChainError";
-  }
-};
-var SwitchChainNotSupportedError = class extends Error {
-  constructor({ connector }) {
-    super(`"${connector.name}" does not support programmatic chain switching.`);
-    this.name = "SwitchChainNotSupportedError";
+// src/utils/assertActiveChain.ts
+function assertActiveChain({
+  chainId,
+  walletClient
+}) {
+  const { chain: activeChain, chains } = getNetwork();
+  const activeChainId = activeChain?.id;
+  if (activeChainId && chainId !== activeChainId) {
+    throw new ChainMismatchError({
+      activeChain: chains.find((x) => x.id === activeChainId)?.name ?? `Chain ${activeChainId}`,
+      targetChain: chains.find((x) => x.id === chainId)?.name ?? `Chain ${chainId}`
+    });
   }
-};
-var UserRejectedRequestError = class extends ProviderRpcError {
-  constructor(cause) {
-    super("User rejected request", { cause, code: 4001 });
-    this.name = "UserRejectedRequestError";
+  if (walletClient) {
+    const walletClientChainId = walletClient.chain.id;
+    if (walletClientChainId && chainId !== walletClientChainId) {
+      const connector = getClient().connector;
+      throw new ChainNotConfiguredError({
+        chainId,
+        connectorId: connector?.id ?? "unknown"
+      });
+    }
   }
-};
+}
 
 export {
   configureChains,
-  RpcError,
-  ProviderRpcError,
-  AddChainError,
-  ChainDoesNotSupportMulticallError,
   ChainMismatchError,
   ChainNotConfiguredError,
   ConnectorAlreadyConnectedError,
-  ConnectorNotFoundError,
-  ContractMethodDoesNotExistError,
-  ContractMethodNoResultError,
-  ContractMethodRevertedError,
-  ContractResultDecodeError,
-  ProviderChainsNotFound,
-  ResourceUnavailableError,
-  SwitchChainError,
+  ClientChainsNotFound,
   SwitchChainNotSupportedError,
-  UserRejectedRequestError,
-  debounce,
+  ConnectorNotFoundError,
   deepEqual,
   deserialize,
-  minimizeContractInterface,
-  normalizeChainId,
-  parseContractResult,
+  getCallParameters,
+  getSendTransactionParameters,
+  getUnit,
   serialize,
   noopStorage,
   createStorage,
@@ -3326,36 +2799,25 @@ export {
   erc20ABI,
   erc721ABI,
   erc4626ABI,
-  units,
   fetchToken,
-  getContract,
+  getPublicClient,
+  getWalletClient,
+  getWebSocketPublicClient,
+  watchPublicClient,
+  watchWalletClient,
+  watchWebSocketPublicClient,
   prepareWriteContract,
-  getProvider,
-  getWebSocketProvider,
-  watchProvider,
-  watchWebSocketProvider,
+  getContract,
   multicall,
   readContract,
   readContracts,
   watchContractEvent,
-  fetchBlockNumber,
   watchBlockNumber,
   watchMulticall,
   watchReadContract,
   watchReadContracts,
-  fetchTransaction,
-  fetchEnsAddress,
-  fetchEnsAvatar,
-  fetchEnsName,
-  fetchEnsResolver,
-  prepareSendTransaction,
-  sendTransaction,
-  fetchFeeData,
-  waitForTransaction,
-  watchPendingTransactions,
   writeContract,
   fetchBalance,
-  fetchSigner,
   getAccount,
   getNetwork,
   signMessage,
@@ -3363,5 +2825,15 @@ export {
   switchNetwork,
   watchAccount,
   watchNetwork,
-  watchSigner
+  fetchEnsAddress,
+  fetchEnsAvatar,
+  fetchEnsName,
+  fetchEnsResolver,
+  fetchBlockNumber,
+  fetchFeeData,
+  fetchTransaction,
+  prepareSendTransaction,
+  sendTransaction,
+  waitForTransaction,
+  watchPendingTransactions
 };