@wagmi/core 0.5.7 → 0.6.0

package/dist/wagmi-core.esm.js

@@ -1,13 +1,13 @@
-import { g as getClient, C as ConnectorAlreadyConnectedError, a as ConnectorNotFoundError, b as ChainMismatchError, U as UserRejectedRequestError, c as ContractMethodDoesNotExistError, d as getProvider, P as ProviderChainsNotFound, e as ChainDoesNotSupportMulticallError, f as ContractMethodRevertedError, h as ContractMethodNoResultError, i as ContractResultDecodeError, n as normalizeChainId, S as SwitchChainNotSupportedError } from './getProvider-f1dfc7e3.esm.js';
-export { A as AddChainError, e as ChainDoesNotSupportMulticallError, b as ChainMismatchError, m as ChainNotConfiguredError, k as Client, l as Connector, C as ConnectorAlreadyConnectedError, a as ConnectorNotFoundError, c as ContractMethodDoesNotExistError, h as ContractMethodNoResultError, f as ContractMethodRevertedError, i as ContractResultDecodeError, I as InjectedConnector, P as ProviderChainsNotFound, o as ProviderRpcError, R as ResourceUnavailableError, p as RpcError, q as SwitchChainError, S as SwitchChainNotSupportedError, U as UserRejectedRequestError, j as createClient, r as createStorage, d as getProvider, s as noopStorage, n as normalizeChainId } from './getProvider-f1dfc7e3.esm.js';
-import { providers, Contract as Contract$1 } from 'ethers';
+import { C as ChainMismatchError, g as getClient, a as ConnectorAlreadyConnectedError, b as ContractResultDecodeError, c as ConnectorNotFoundError, d as ContractMethodDoesNotExistError, e as getProvider, P as ProviderChainsNotFound, f as ChainDoesNotSupportMulticallError, h as ContractMethodRevertedError, i as ContractMethodNoResultError, U as UserRejectedRequestError, n as normalizeChainId, S as SwitchChainNotSupportedError } from './getProvider-24ec6544.esm.js';
+export { A as AddChainError, f as ChainDoesNotSupportMulticallError, C as ChainMismatchError, m as ChainNotConfiguredError, k as Client, l as Connector, a as ConnectorAlreadyConnectedError, c as ConnectorNotFoundError, d as ContractMethodDoesNotExistError, i as ContractMethodNoResultError, h as ContractMethodRevertedError, b as ContractResultDecodeError, I as InjectedConnector, P as ProviderChainsNotFound, o as ProviderRpcError, R as ResourceUnavailableError, p as RpcError, q as SwitchChainError, S as SwitchChainNotSupportedError, U as UserRejectedRequestError, j as createClient, r as createStorage, e as getProvider, s as noopStorage, n as normalizeChainId } from './getProvider-24ec6544.esm.js';
 import { Contract, logger } from 'ethers/lib/ethers';
-import { FormatTypes, formatUnits, getAddress, isAddress, Logger } from 'ethers/lib/utils';
-import { m as mainnet } from './chains-8c76af1b.esm.js';
-export { a as allChains, c as chain, b as chainId, d as defaultChains, e as defaultL2Chains, f as etherscanBlockExplorers } from './chains-8c76af1b.esm.js';
+import { FunctionFragment, isAddress, FormatTypes, parseBytes32String, formatUnits, getAddress, Logger } from 'ethers/lib/utils';
+import { providers, BigNumber, Contract as Contract$1 } from 'ethers';
+import { m as mainnet } from './chains-2970e5fa.esm.js';
+export { a as allChains, c as chain, b as chainId, d as defaultChains, e as defaultL2Chains, f as etherscanBlockExplorers } from './chains-2970e5fa.esm.js';
 import shallow from 'zustand/shallow';
 import { d as debounce } from './debounce-0862bf88.esm.js';
-export { a as alchemyRpcUrls, i as infuraRpcUrls, p as publicRpcUrls } from './rpcs-8d636858.esm.js';
+export { a as alchemyRpcUrls, i as infuraRpcUrls, p as publicRpcUrls } from './rpcs-b4aa70b9.esm.js';
 import 'zustand/middleware';
 import 'zustand/vanilla';
 import 'eventemitter3';
@@ -15,7 +15,7 @@ import 'eventemitter3';
 function configureChains(defaultChains, providers) {
   let {
     minQuorum = 1,
-    pollingInterval = 4000,
+    pollingInterval = 4_000,
     targetQuorum = 1,
     stallTimeout
   } = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
@@ -54,48 +54,63 @@ function configureChains(defaultChains, providers) {
 
 
     if (!configExists) {
-      throw new Error(["Could not find valid provider configuration for chain \"".concat(chain.name, "\".\n"), "You may need to add `jsonRpcProvider` to `configureChains` with the chain's RPC URLs.", 'Read more: https://wagmi.sh/docs/providers/jsonRpc'].join('\n'));
+      throw new Error([`Could not find valid provider configuration for chain "${chain.name}".\n`, "You may need to add `jsonRpcProvider` to `configureChains` with the chain's RPC URLs.", 'Read more: https://wagmi.sh/docs/providers/jsonRpc'].join('\n'));
     }
   }
 
   return {
     chains,
     provider: _ref2 => {
-      var _defaultChains$;
-
       let {
         chainId
       } = _ref2;
-      const activeChainId = chainId && chains.some(x => x.id === chainId) ? chainId : (_defaultChains$ = defaultChains[0]) === null || _defaultChains$ === void 0 ? void 0 : _defaultChains$.id;
-      const chainProviders = providers_[activeChainId];
-      if (!chainProviders || !chainProviders[0]) throw new Error("No providers configured for chain \"".concat(activeChainId, "\""));
+      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}"`);
+      let provider;
 
       if (chainProviders.length === 1) {
-        return Object.assign(chainProviders[0](), {
-          chains,
-          pollingInterval
+        provider = chainProviders[0]();
+      } else {
+        provider = fallbackProvider(targetQuorum, minQuorum, chainProviders, {
+          stallTimeout
         });
+      } // Formatter workaround as Celo does not provide `gasLimit` or `difficulty` on eth_getBlockByNumber.
+
+
+      if (activeChain.id === 42220) {
+        provider.formatter.formats.block = { ...provider.formatter.formats.block,
+          difficulty: () => 0,
+          gasLimit: () => 0
+        };
       }
 
-      return Object.assign(fallbackProvider(targetQuorum, minQuorum, chainProviders, {
-        stallTimeout
-      }), {
+      return Object.assign(provider, {
         chains,
         pollingInterval
       });
     },
     webSocketProvider: _ref3 => {
-      var _defaultChains$2, _chainWebSocketProvid;
+      var _chainWebSocketProvid;
 
       let {
         chainId
       } = _ref3;
-      const activeChainId = chainId && chains.some(x => x.id === chainId) ? chainId : (_defaultChains$2 = defaultChains[0]) === null || _defaultChains$2 === void 0 ? void 0 : _defaultChains$2.id;
-      const chainWebSocketProviders = webSocketProviders_[activeChainId];
-      if (!chainWebSocketProviders) return undefined; // WebSockets do not work with `fallbackProvider`
+      const activeChain = chains.find(x => x.id === chainId) ?? defaultChains[0];
+      const chainWebSocketProviders = webSocketProviders_[activeChain.id];
+      if (!chainWebSocketProviders) return undefined;
+      const provider = (_chainWebSocketProvid = chainWebSocketProviders[0]) === null || _chainWebSocketProvid === void 0 ? void 0 : _chainWebSocketProvid.call(chainWebSocketProviders); // Formatter workaround as Celo does not provide `gasLimit` or `difficulty` on eth_getBlockByNumber.
+
+      if (provider && activeChain.id === 42220) {
+        provider.formatter.formats.block = { ...provider.formatter.formats.block,
+          difficulty: () => 0,
+          gasLimit: () => 0
+        };
+      } // WebSockets do not work with `fallbackProvider`
       // Default to first available
 
-      return Object.assign(((_chainWebSocketProvid = chainWebSocketProviders[0]) === null || _chainWebSocketProvid === void 0 ? void 0 : _chainWebSocketProvid.call(chainWebSocketProviders)) || {}, {
+
+      return Object.assign(provider || {}, {
         chains
       });
     }
@@ -109,13 +124,11 @@ function fallbackProvider(targetQuorum, minQuorum, providers_, _ref4) {
 
   try {
     return new providers.FallbackProvider(providers_.map((chainProvider, index) => {
-      var _provider$priority, _provider$stallTimeou;
-
       const provider = chainProvider();
       return {
         provider,
-        priority: (_provider$priority = provider.priority) !== null && _provider$priority !== void 0 ? _provider$priority : index,
-        stallTimeout: (_provider$stallTimeou = provider.stallTimeout) !== null && _provider$stallTimeou !== void 0 ? _provider$stallTimeou : stallTimeout,
+        priority: provider.priority ?? index,
+        stallTimeout: provider.stallTimeout ?? stallTimeout,
         weight: provider.weight
       };
     }), targetQuorum);
@@ -133,6 +146,26 @@ function fallbackProvider(targetQuorum, minQuorum, providers_, _ref4) {
   }
 }
 
+function assertActiveChain(_ref) {
+  let {
+    chainId
+  } = _ref;
+  const {
+    chain: activeChain,
+    chains
+  } = getNetwork();
+  const activeChainId = activeChain === null || activeChain === void 0 ? void 0 : activeChain.id;
+
+  if (chainId !== activeChainId) {
+    var _chains$find, _chains$find2;
+
+    throw new ChainMismatchError({
+      activeChain: ((_chains$find = chains.find(x => x.id === activeChainId)) === null || _chains$find === void 0 ? void 0 : _chains$find.name) ?? `Chain ${activeChainId}`,
+      targetChain: ((_chains$find2 = chains.find(x => x.id === chainId)) === null || _chains$find2 === void 0 ? void 0 : _chains$find2.name) ?? `Chain ${chainId}`
+    });
+  }
+}
+
 /** Forked from https://github.com/epoberezkin/fast-deep-equal */
 function deepEqual(a, b) {
   if (a === b) return true;
@@ -171,20 +204,100 @@ function deepEqual(a, b) {
   return a !== a && b !== b;
 }
 
+/**
+ * Get normalized function name from contract
+ *
+ * @param contract — Contract
+ * @param functionName — Function name
+ * @param args — Function arguments (used to disambiguate overloaded functions)
+ *
+ * @returns Normalized function name
+ */
+
+function normalizeFunctionName(_ref) {
+  let {
+    contract,
+    functionName,
+    args = []
+  } = _ref;
+  // If `functionName` exists in contract, return it.
+  if (functionName in contract.functions) return functionName; // Otherwise, check if `functionName` is an overloaded function based on `args` shape.
+
+  const argsLength = (args === null || args === void 0 ? void 0 : 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;
+  } // Wasn't able to find overload, just return function 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);
+        }); // `(u)int<M>`: (un)signed integer type of `M` bits, `0 < M <= 256`, `M % 8 == 0`
+        // https://regexr.com/6v8hp
+
+        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' || BigNumber.isBigNumber(arg); // `bytes<M>`: binary type of `M` bytes, `0 < M <= 32`
+        // https://regexr.com/6va55
+
+        if (/^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/.test(abiParameterType)) return argType === 'string' || arg instanceof Uint8Array; // fixed-length (`<type>[M]`) and dynamic (`<type>[]`) arrays
+        // https://regexr.com/6va6i
+
+        if (/[a-z]+[1-9]{0,3}(\[[0-9]{0,}\])+$/.test(abiParameterType)) {
+          return Array.isArray(arg) && arg.every(x => isArgOfType(x, { ...abiParameter,
+            // Pop off `[]` or `[M]` from end of type
+            type: abiParameterType.replace(/(\[[0-9]{0,}\])$/, '')
+          }));
+        }
+
+        return false;
+      }
+  }
+}
+
 function logWarn(message) {
   var _getClient, _getClient$config$log, _getClient$config$log2;
 
   (_getClient = getClient()) === null || _getClient === void 0 ? void 0 : (_getClient$config$log = _getClient.config.logger) === null || _getClient$config$log === void 0 ? void 0 : (_getClient$config$log2 = _getClient$config$log.warn) === null || _getClient$config$log2 === void 0 ? void 0 : _getClient$config$log2.call(_getClient$config$log, message);
 }
 
-function minimizeContractInterface(_ref) {
-  let {
-    contractInterface,
-    functionName
-  } = _ref;
-  const abi = Contract.getInterface(contractInterface).format(FormatTypes.full);
-  const minimizedInterface = Array.isArray(abi) ? abi : [abi];
-  return minimizedInterface.filter(i => i.includes(functionName));
+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));
+  }
 }
 
 function isPlainArray(value) {
@@ -193,7 +306,7 @@ function isPlainArray(value) {
 
 function parseContractResult(_ref) {
   let {
-    contractInterface,
+    abi,
     data,
     functionName
   } = _ref;
@@ -201,7 +314,7 @@ function parseContractResult(_ref) {
   if (data && isPlainArray(data)) {
     var _fragment$outputs;
 
-    const iface = Contract.getInterface(contractInterface);
+    const iface = Contract.getInterface(abi);
     const fragment = iface.getFunction(functionName);
     const isTuple = (((_fragment$outputs = fragment.outputs) === null || _fragment$outputs === void 0 ? void 0 : _fragment$outputs.length) || 0) > 1;
     const data_ = isTuple ? data : [data];
@@ -213,42 +326,572 @@ function parseContractResult(_ref) {
   return data;
 }
 
-// https://ethereum.org/en/developers/docs/standards/tokens/erc-20
-const erc20ABI = ['event Approval(address indexed _owner, address indexed _spender, uint256 _value)', 'event Transfer(address indexed _from, address indexed _to, uint256 _value)', 'function allowance(address _owner, address _spender) public view returns (uint256 remaining)', 'function approve(address _spender, uint256 _value) public returns (bool success)', 'function balanceOf(address _owner) public view returns (uint256 balance)', 'function decimals() public view returns (uint8)', 'function name() public view returns (string)', 'function symbol() public view returns (string)', 'function totalSupply() public view returns (uint256)', 'function transfer(address _to, uint256 _value) public returns (bool success)', 'function transferFrom(address _from, address _to, uint256 _value) public returns (bool success)']; // https://ethereum.org/en/developers/docs/standards/tokens/erc-721
+/**
+ * [ERC-20 Token Standard](https://ethereum.org/en/developers/docs/standards/tokens/erc-20)
+ */
+const 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'
+  }]
+}, {
+  type: 'function',
+  name: 'allowance',
+  stateMutability: 'view',
+  inputs: [{
+    name: 'owner',
+    type: 'address'
+  }, {
+    name: 'spender',
+    type: 'address'
+  }],
+  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: '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'
+  }],
+  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'
+  }]
+}];
+/**
+ * [bytes32-flavored ERC-20](https://docs.makerdao.com/smart-contract-modules/mkr-module#4.-gotchas-potential-source-of-user-error)
+ * for tokens (ie. Maker) that use bytes32 instead of string.
+ */
 
-const erc721ABI = ['event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId)', 'event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved)', 'event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId)', 'function approve(address _approved, uint256 _tokenId) external payable', 'function balanceOf(address _owner) external view returns (uint256)', 'function getApproved(uint256 _tokenId) external view returns (address)', 'function isApprovedForAll(address _owner, address _operator) external view returns (bool)', 'function name() view returns (string memory)', 'function ownerOf(uint256 _tokenId) external view returns (address)', 'function safeTransferFrom(address _from, address _to, uint256 _tokenId) external payable', 'function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes data) external payable', 'function setApprovalForAll(address _operator, bool _approved) external', 'function symbol() view returns (string memory)', 'function tokenByIndex(uint256 _index) view returns (uint256)', 'function tokenOfOwnerByIndex(address _owner, uint256 _index) view returns (uint256 tokenId)', 'function tokenURI(uint256 _tokenId) view returns (string memory)', 'function totalSupply() view returns (uint256)', 'function transferFrom(address _from, address _to, uint256 _tokenId) external payable'];
+const erc20ABI_bytes32 = [{
+  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'
+  }]
+}, {
+  type: 'function',
+  name: 'allowance',
+  stateMutability: 'view',
+  inputs: [{
+    name: 'owner',
+    type: 'address'
+  }, {
+    name: 'spender',
+    type: 'address'
+  }],
+  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'
+  }]
+}];
+/**
+ * [ERC-721 Non-Fungible Token Standard](https://ethereum.org/en/developers/docs/standards/tokens/erc-721)
+ */
 
-const multicallInterface = [{
+const 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',
+  name: 'approve',
+  stateMutability: 'payable',
+  inputs: [{
+    name: 'spender',
+    type: 'address'
+  }, {
+    name: 'tokenId',
+    type: 'uint256'
+  }],
+  outputs: []
+}, {
+  type: 'function',
+  name: 'balanceOf',
+  stateMutability: 'view',
+  inputs: [{
+    name: 'account',
+    type: 'address'
+  }],
+  outputs: [{
+    name: '',
+    type: 'uint256'
+  }]
+}, {
+  type: 'function',
+  name: 'getApproved',
+  stateMutability: 'view',
+  inputs: [{
+    name: 'tokenId',
+    type: 'uint256'
+  }],
+  outputs: [{
+    name: '',
+    type: 'address'
+  }]
+}, {
+  type: 'function',
+  name: 'isApprovedForAll',
+  stateMutability: 'view',
+  inputs: [{
+    name: 'owner',
+    type: 'address'
+  }, {
+    name: 'operator',
+    type: 'address'
+  }],
+  outputs: [{
+    name: '',
+    type: 'bool'
+  }]
+}, {
+  type: 'function',
+  name: 'name',
+  stateMutability: 'view',
+  inputs: [],
+  outputs: [{
+    name: '',
+    type: 'string'
+  }]
+}, {
+  type: 'function',
+  name: 'ownerOf',
+  stateMutability: 'view',
+  inputs: [{
+    name: 'tokenId',
+    type: 'uint256'
+  }],
+  outputs: [{
+    name: 'owner',
+    type: 'address'
+  }]
+}, {
+  type: 'function',
+  name: 'safeTransferFrom',
+  stateMutability: 'payable',
+  inputs: [{
+    name: 'from',
+    type: 'address'
+  }, {
+    name: 'to',
+    type: 'address'
+  }, {
+    name: 'tokenId',
+    type: 'uint256'
+  }],
+  outputs: []
+}, {
+  type: 'function',
+  name: 'safeTransferFrom',
+  stateMutability: 'nonpayable',
+  inputs: [{
+    name: 'from',
+    type: 'address'
+  }, {
+    name: 'to',
+    type: 'address'
+  }, {
+    name: 'id',
+    type: 'uint256'
+  }, {
+    name: 'data',
+    type: 'bytes'
+  }],
+  outputs: []
+}, {
+  type: 'function',
+  name: 'setApprovalForAll',
+  stateMutability: 'nonpayable',
+  inputs: [{
+    name: 'operator',
+    type: 'address'
+  }, {
+    name: 'approved',
+    type: 'bool'
+  }],
+  outputs: []
+}, {
+  type: 'function',
+  name: 'symbol',
+  stateMutability: 'view',
+  inputs: [],
+  outputs: [{
+    name: '',
+    type: 'string'
+  }]
+}, {
+  type: 'function',
+  name: 'tokenByIndex',
+  stateMutability: 'view',
+  inputs: [{
+    name: 'index',
+    type: 'uint256'
+  }],
+  outputs: [{
+    name: '',
+    type: 'uint256'
+  }]
+}, {
+  type: 'function',
+  name: 'tokenByIndex',
+  stateMutability: 'view',
+  inputs: [{
+    name: 'owner',
+    type: 'address'
+  }, {
+    name: 'index',
+    type: 'uint256'
+  }],
+  outputs: [{
+    name: 'tokenId',
+    type: 'uint256'
+  }]
+}, {
+  type: 'function',
+  name: 'tokenURI',
+  stateMutability: 'view',
+  inputs: [{
+    name: 'tokenId',
+    type: 'uint256'
+  }],
+  outputs: [{
+    name: '',
+    type: 'string'
+  }]
+}, {
+  type: 'function',
+  name: 'totalSupply',
+  stateMutability: 'view',
+  inputs: [],
+  outputs: [{
+    name: '',
+    type: 'uint256'
+  }]
+}, {
+  type: 'function',
+  name: 'transferFrom',
+  stateMutability: 'payable',
+  inputs: [{
+    name: 'sender',
+    type: 'address'
+  }, {
+    name: 'recipient',
+    type: 'address'
+  }, {
+    name: 'tokeId',
+    type: 'uint256'
+  }],
+  outputs: []
+}];
+/**
+ * [Multicall3](https://github.com/mds1/multicall)
+ */
+
+const multicallABI = [{
   inputs: [{
     components: [{
-      internalType: 'address',
       name: 'target',
       type: 'address'
     }, {
-      internalType: 'bool',
       name: 'allowFailure',
       type: 'bool'
     }, {
-      internalType: 'bytes',
       name: 'callData',
       type: 'bytes'
     }],
-    internalType: 'struct Multicall3.Call3[]',
     name: 'calls',
     type: 'tuple[]'
   }],
   name: 'aggregate3',
   outputs: [{
     components: [{
-      internalType: 'bool',
       name: 'success',
       type: 'bool'
     }, {
-      internalType: 'bytes',
       name: 'returnData',
       type: 'bytes'
     }],
-    internalType: 'struct Multicall3.Result[]',
     name: 'returnData',
     type: 'tuple[]'
   }],
@@ -304,101 +947,85 @@ async function disconnect() {
   client.storage.removeItem('connected');
 }
 
-function getContract(_ref) {
-  let {
-    addressOrName,
-    contractInterface,
-    signerOrProvider
-  } = _ref;
-  return new Contract$1(addressOrName, contractInterface, signerOrProvider);
-}
-
-async function deprecatedWriteContract(_ref) {
+async function fetchToken(_ref) {
   let {
-    addressOrName,
-    args,
+    address,
     chainId,
-    contractInterface,
-    functionName,
-    overrides,
-    signerOrProvider
+    formatUnits: units = 'ether'
   } = _ref;
-  const {
-    connector
-  } = getClient();
-  if (!connector) throw new ConnectorNotFoundError();
-  const params = [...(Array.isArray(args) ? args : args ? [args] : []), ...(overrides ? [overrides] : [])];
-
-  try {
-    var _chain;
-
-    let chain;
-
-    if (chainId) {
-      const activeChainId = await connector.getChainId(); // Try to switch chain to provided `chainId`
 
-      if (chainId !== activeChainId) {
-        var _connector$chains$fin, _connector$chains$fin2, _connector$chains$fin3, _connector$chains$fin4;
-
-        if (connector.switchChain) chain = await connector.switchChain(chainId);else throw new ChainMismatchError({
-          activeChain: (_connector$chains$fin = (_connector$chains$fin2 = connector.chains.find(x => x.id === activeChainId)) === null || _connector$chains$fin2 === void 0 ? void 0 : _connector$chains$fin2.name) !== null && _connector$chains$fin !== void 0 ? _connector$chains$fin : "Chain ".concat(activeChainId),
-          targetChain: (_connector$chains$fin3 = (_connector$chains$fin4 = connector.chains.find(x => x.id === chainId)) === null || _connector$chains$fin4 === void 0 ? void 0 : _connector$chains$fin4.name) !== null && _connector$chains$fin3 !== void 0 ? _connector$chains$fin3 : "Chain ".concat(chainId)
-        });
+  async function fetchToken_(_ref2) {
+    let {
+      abi
+    } = _ref2;
+    const erc20Config = {
+      address,
+      abi,
+      chainId
+    };
+    const [decimals, name, symbol, totalSupply] = await readContracts({
+      allowFailure: false,
+      contracts: [{ ...erc20Config,
+        functionName: 'decimals'
+      }, { ...erc20Config,
+        functionName: 'name'
+      }, { ...erc20Config,
+        functionName: 'symbol'
+      }, { ...erc20Config,
+        functionName: 'totalSupply'
+      }]
+    });
+    return {
+      address,
+      decimals,
+      name: name,
+      // protect against `ResolvedConfig['BytesType']`
+      symbol: symbol,
+      // protect against `ResolvedConfig['BytesType']`
+      totalSupply: {
+        formatted: formatUnits(totalSupply, units),
+        value: totalSupply
       }
-    }
+    };
+  }
 
-    const signer = await connector.getSigner({
-      chainId: (_chain = chain) === null || _chain === void 0 ? void 0 : _chain.id
-    });
-    const contract = getContract({
-      addressOrName,
-      contractInterface,
-      signerOrProvider
+  try {
+    return await fetchToken_({
+      abi: erc20ABI
     });
-    const contractWithSigner = contract.connect(signer);
-    const contractFunction = contractWithSigner[functionName];
-    if (!contractFunction) logWarn("\"".concat(functionName, "\" does not exist in interface for contract \"").concat(addressOrName, "\""));
-    return await contractFunction(...params);
-  } catch (error) {
-    if (error.code === 4001) throw new UserRejectedRequestError(error);
-    throw error;
+  } catch (err) {
+    // In the chance that there is an error upon decoding the contract result,
+    // it could be likely that the contract data is represented as bytes32 instead
+    // of a string.
+    if (err instanceof ContractResultDecodeError) {
+      const {
+        name,
+        symbol,
+        ...rest
+      } = await fetchToken_({
+        abi: erc20ABI_bytes32
+      });
+      return {
+        name: parseBytes32String(name),
+        symbol: parseBytes32String(symbol),
+        ...rest
+      };
+    }
+
+    throw err;
   }
 }
 
-async function fetchToken(_ref) {
+function getContract(_ref) {
   let {
     address,
-    chainId,
-    formatUnits: units = 'ether'
+    abi,
+    signerOrProvider
   } = _ref;
-  const erc20Config = {
-    addressOrName: address,
-    contractInterface: erc20ABI,
-    chainId
-  };
-  const [decimals, name, symbol, totalSupply] = await readContracts({
-    allowFailure: false,
-    contracts: [{ ...erc20Config,
-      functionName: 'decimals'
-    }, { ...erc20Config,
-      functionName: 'name'
-    }, { ...erc20Config,
-      functionName: 'symbol'
-    }, { ...erc20Config,
-      functionName: 'totalSupply'
-    }]
-  });
-  return {
-    address,
-    decimals,
-    name,
-    symbol,
-    totalSupply: {
-      formatted: formatUnits(totalSupply, units),
-      value: totalSupply
-    }
-  };
-}
+  return new Contract$1(address, abi, signerOrProvider);
+} ////////////////////////////////////////////////////////////////////////////////////////////////////
+// Contract
+// TODO: Add remaining properties
 
 /**
  * @description Prepares the parameters required for a contract write transaction.
@@ -409,58 +1036,63 @@ async function fetchToken(_ref) {
  * import { prepareWriteContract, writeContract } from '@wagmi/core'
  *
  * const config = await prepareWriteContract({
- *  addressOrName: '0x...',
- *  contractInterface: wagmiAbi,
+ *  address: '0x...',
+ *  abi: wagmiAbi,
  *  functionName: 'mint',
  * })
  * const result = await writeContract(config)
  */
 async function prepareWriteContract(_ref) {
   let {
-    addressOrName,
+    abi,
+    address,
     args,
     chainId,
-    contractInterface: contractInterface_,
     functionName,
     overrides,
     signer: signer_
   } = _ref;
-  const signer = signer_ !== null && signer_ !== void 0 ? signer_ : await fetchSigner();
+  const signer = signer_ ?? (await fetchSigner({
+    chainId
+  }));
   if (!signer) throw new ConnectorNotFoundError();
+  if (chainId) assertActiveChain({
+    chainId
+  });
   const contract = getContract({
-    addressOrName,
-    contractInterface: contractInterface_,
+    address,
+    abi: abi,
+    // TODO: Remove cast and still support `Narrow<TAbi>`
     signerOrProvider: signer
   });
-  const populateTransactionFn = contract.populateTransaction[functionName];
-
-  if (!populateTransactionFn) {
-    throw new ContractMethodDoesNotExistError({
-      addressOrName,
-      functionName
-    });
-  }
-
-  const contractInterface = minimizeContractInterface({
-    contractInterface: contract.interface,
-    functionName
+  const normalizedFunctionName = normalizeFunctionName({
+    contract,
+    functionName,
+    args
+  });
+  const populateTransactionFn = contract.populateTransaction[normalizedFunctionName];
+  if (!populateTransactionFn) throw new ContractMethodDoesNotExistError({
+    address,
+    functionName: normalizedFunctionName
   });
-  const params = [...(Array.isArray(args) ? args : args ? [args] : []), ...(overrides ? [overrides] : [])];
+  const params = [...(args ?? []), ...(overrides ? [overrides] : [])];
   const unsignedTransaction = await populateTransactionFn(...params);
   const gasLimit = unsignedTransaction.gasLimit || (await signer.estimateGas(unsignedTransaction));
+  const minimizedAbi = minimizeContractInterface({
+    abi: abi,
+    // TODO: Remove cast and still support `Narrow<TAbi>`
+    functionName
+  });
   return {
-    addressOrName,
-    args,
-    ...(chainId ? {
-      chainId
-    } : {}),
-    contractInterface,
-    functionName,
-    overrides,
+    abi: minimizedAbi,
+    address,
+    chainId,
+    // TODO: Remove cast
+    functionName: functionName,
+    mode: 'prepared',
     request: { ...unsignedTransaction,
       gasLimit
-    },
-    mode: 'prepared'
+    }
   };
 }
 
@@ -503,30 +1135,6 @@ function watchWebSocketProvider(args, callback) {
   return unsubscribe;
 }
 
-async function readContract(_ref) {
-  let {
-    addressOrName,
-    args,
-    chainId,
-    contractInterface,
-    functionName,
-    overrides
-  } = _ref;
-  const provider = getProvider({
-    chainId
-  });
-  const contract = getContract({
-    addressOrName,
-    contractInterface,
-    signerOrProvider: provider
-  });
-  const params = [...(Array.isArray(args) ? args : args ? [args] : []), ...(overrides ? [overrides] : [])];
-  const contractFunction = contract[functionName];
-  if (!contractFunction) logWarn("\"".concat(functionName, "\" is not in the interface for contract \"").concat(addressOrName, "\""));
-  const response = await (contractFunction === null || contractFunction === void 0 ? void 0 : contractFunction(...params));
-  return response;
-}
-
 async function multicall(_ref) {
   let {
     allowFailure = true,
@@ -548,14 +1156,14 @@ async function multicall(_ref) {
     chain
   });
   const multicallContract = getContract({
-    addressOrName: chain.multicall.address,
-    contractInterface: multicallInterface,
+    address: chain.multicall.address,
+    abi: multicallABI,
     signerOrProvider: provider
   });
   const calls = contracts.map(_ref2 => {
     let {
-      addressOrName,
-      contractInterface,
+      address,
+      abi,
       functionName,
       ...config
     } = _ref2;
@@ -563,57 +1171,71 @@ async function multicall(_ref) {
       args
     } = config || {};
     const contract = getContract({
-      addressOrName,
-      contractInterface
+      address,
+      abi
+    });
+    const params = args ?? [];
+    const normalizedFunctionName = normalizeFunctionName({
+      contract,
+      functionName,
+      args
     });
-    const params = Array.isArray(args) ? args : args ? [args] : [];
 
     try {
-      const callData = contract.interface.encodeFunctionData(functionName, params);
-      if (!contract[functionName]) logWarn("\"".concat(functionName, "\" is not in the interface for contract \"").concat(addressOrName, "\""));
+      const contractFunction = contract[normalizedFunctionName];
+      if (!contractFunction) logWarn(`"${normalizedFunctionName}" is not in the interface for contract "${address}"`);
+      const callData = contract.interface.encodeFunctionData(normalizedFunctionName, params);
       return {
-        target: addressOrName,
+        target: address,
         allowFailure,
         callData
       };
     } catch (err) {
       if (!allowFailure) throw err;
       return {
-        target: addressOrName,
+        target: address,
         allowFailure,
         callData: '0x'
       };
     }
   });
   const params = [...[calls], ...(overrides ? [overrides] : [])];
-  const results = await multicallContract.aggregate3(...params);
+  const results = await multicallContract.aggregate3( // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore
+  ...params);
   return results.map((_ref3, i) => {
     let {
       returnData,
       success
     } = _ref3;
     const {
-      addressOrName,
-      contractInterface,
-      functionName,
-      args
+      address,
+      abi,
+      args,
+      functionName
     } = contracts[i];
     const contract = getContract({
-      addressOrName,
-      contractInterface
+      address,
+      abi: abi // TODO: Remove cast and still support `Narrow<TAbi>`
+
+    });
+    const normalizedFunctionName = normalizeFunctionName({
+      contract,
+      functionName,
+      args
     });
 
     if (!success) {
       let error;
 
       try {
-        contract.interface.decodeFunctionResult(functionName, returnData);
+        contract.interface.decodeFunctionResult(normalizedFunctionName, returnData);
       } catch (err) {
         error = new ContractMethodRevertedError({
-          addressOrName,
+          address,
           args,
           chainId: chain.id,
-          functionName,
+          functionName: normalizedFunctionName,
           errorMessage: err.message
         });
         if (!allowFailure) throw error;
@@ -625,10 +1247,10 @@ async function multicall(_ref) {
 
     if (returnData === '0x') {
       const error = new ContractMethodNoResultError({
-        addressOrName,
+        address,
         args,
         chainId: chain.id,
-        functionName
+        functionName: normalizedFunctionName
       });
       if (!allowFailure) throw error;
       logWarn(error.message);
@@ -636,14 +1258,14 @@ async function multicall(_ref) {
     }
 
     try {
-      const result = contract.interface.decodeFunctionResult(functionName, returnData);
+      const result = contract.interface.decodeFunctionResult(normalizedFunctionName, returnData);
       return Array.isArray(result) && result.length === 1 ? result[0] : result;
     } catch (err) {
       const error = new ContractResultDecodeError({
-        addressOrName,
+        address,
         args,
         chainId: chain.id,
-        functionName,
+        functionName: normalizedFunctionName,
         errorMessage: err.message
       });
       if (!allowFailure) throw error;
@@ -653,6 +1275,38 @@ async function multicall(_ref) {
   });
 }
 
+async function readContract(_ref) {
+  let {
+    address,
+    args,
+    chainId,
+    abi,
+    functionName,
+    overrides
+  } = _ref;
+  const provider = getProvider({
+    chainId
+  });
+  const contract = getContract({
+    address,
+    abi: abi,
+    // TODO: Remove cast and still support `Narrow<TAbi>`
+    signerOrProvider: provider
+  });
+  const normalizedFunctionName = normalizeFunctionName({
+    contract,
+    functionName,
+    args
+  });
+  const contractFunction = contract[normalizedFunctionName];
+  if (!contractFunction) throw new ContractMethodDoesNotExistError({
+    address,
+    functionName: normalizedFunctionName
+  });
+  const params = [...(args ?? []), ...(overrides ? [overrides] : [])];
+  return contractFunction === null || contractFunction === void 0 ? void 0 : contractFunction(...params);
+}
+
 async function readContracts(_ref) {
   let {
     allowFailure = true,
@@ -662,12 +1316,13 @@ async function readContracts(_ref) {
 
   try {
     const provider = getProvider();
-    const contractsByChainId = contracts.reduce((contracts, contract) => {
-      var _contract$chainId;
-
-      const chainId = (_contract$chainId = contract.chainId) !== null && _contract$chainId !== void 0 ? _contract$chainId : provider.network.chainId;
+    const contractsByChainId = contracts.reduce((contracts, contract, index) => {
+      const chainId = contract.chainId ?? provider.network.chainId;
       return { ...contracts,
-        [chainId]: [...(contracts[chainId] || []), contract]
+        [chainId]: [...(contracts[chainId] || []), {
+          contract,
+          index
+        }]
       };
     }, {});
 
@@ -676,13 +1331,20 @@ async function readContracts(_ref) {
       return multicall({
         allowFailure,
         chainId: parseInt(chainId),
-        contracts,
+        contracts: contracts.map(_ref3 => {
+          let {
+            contract
+          } = _ref3;
+          return contract;
+        }),
         overrides
       });
     });
 
+    let results;
+
     if (allowFailure) {
-      return (await Promise.allSettled(promises())).map(result => {
+      results = (await Promise.allSettled(promises())).map(result => {
         if (result.status === 'fulfilled') return result.value;
 
         if (result.reason instanceof ChainDoesNotSupportMulticallError) {
@@ -692,9 +1354,22 @@ async function readContracts(_ref) {
 
         return null;
       }).flat();
-    }
+    } else {
+      results = (await Promise.all(promises())).flat();
+    } // Reorder the contract results back to the order they were
+    // provided in.
+
 
-    return (await Promise.all(promises())).flat();
+    const resultIndexes = Object.values(contractsByChainId).map(contracts => contracts.map(_ref4 => {
+      let {
+        index
+      } = _ref4;
+      return index;
+    })).flat();
+    return results.reduce((results, result, index) => {
+      results[resultIndexes[index]] = result;
+      return results;
+    }, []);
   } catch (err) {
     if (err instanceof ContractResultDecodeError) throw err;
     if (err instanceof ContractMethodNoResultError) throw err;
@@ -704,67 +1379,68 @@ async function readContracts(_ref) {
       overrides
     }));
 
-    if (allowFailure) {
-      return (await Promise.allSettled(promises())).map((result, i) => {
-        if (result.status === 'fulfilled') return result.value;
-        const {
-          addressOrName,
-          functionName,
-          chainId,
-          args
-        } = contracts[i];
-        const error = new ContractMethodRevertedError({
-          addressOrName,
-          functionName,
-          chainId: chainId !== null && chainId !== void 0 ? chainId : mainnet.id,
-          args,
-          errorMessage: result.reason
-        });
-        logWarn(error.message);
-        return null;
+    if (allowFailure) return (await Promise.allSettled(promises())).map((result, i) => {
+      if (result.status === 'fulfilled') return result.value;
+      const {
+        address,
+        args,
+        chainId,
+        functionName
+      } = contracts[i];
+      const error = new ContractMethodRevertedError({
+        address,
+        functionName,
+        chainId: chainId ?? mainnet.id,
+        args,
+        errorMessage: result.reason
       });
-    }
-
+      logWarn(error.message);
+      return null;
+    });
     return await Promise.all(promises());
   }
 }
 
-function watchContractEvent(
-/** Contract configuration */
-contractArgs,
-/** Event name to listen to */
-eventName, callback) {
+function watchContractEvent(_ref, callback) {
   let {
+    address,
+    abi,
     chainId,
+    eventName,
     once
-  } = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+  } = _ref;
+
+  const handler = function () {
+    return callback(...arguments);
+  };
+
   let contract;
 
   const watchEvent = async () => {
-    if (contract) {
-      var _contract;
-
-      (_contract = contract) === null || _contract === void 0 ? void 0 : _contract.off(eventName, callback);
-    }
+    var _contract;
 
+    if (contract) (_contract = contract) === null || _contract === void 0 ? void 0 : _contract.off(eventName, handler);
+    const signerOrProvider = getWebSocketProvider({
+      chainId
+    }) || getProvider({
+      chainId
+    });
     contract = getContract({
-      signerOrProvider: getWebSocketProvider({
-        chainId
-      }) || getProvider({
-        chainId
-      }),
-      ...contractArgs
+      address,
+      abi: abi,
+      // TODO: Remove cast and still support `Narrow<TAbi>`
+      signerOrProvider
     });
-    if (once) contract.once(eventName, callback);else contract.on(eventName, callback);
+    if (once) contract.once(eventName, handler);else contract.on(eventName, handler);
   };
 
   watchEvent();
   const client = getClient();
-  const unsubscribe = client.subscribe(_ref => {
+  const unsubscribe = client.subscribe(_ref2 => {
     let {
       provider,
       webSocketProvider
-    } = _ref;
+    } = _ref2;
     return {
       provider,
       webSocketProvider
@@ -775,7 +1451,7 @@ eventName, callback) {
   return () => {
     var _contract2;
 
-    (_contract2 = contract) === null || _contract2 === void 0 ? void 0 : _contract2.off(eventName, callback);
+    (_contract2 = contract) === null || _contract2 === void 0 ? void 0 : _contract2.off(eventName, handler);
     unsubscribe();
   };
 }
@@ -792,18 +1468,15 @@ async function fetchBlockNumber() {
 }
 
 function watchBlockNumber(args, callback) {
-  var _client$webSocketProv;
-
+  // We need to debounce the listener as we want to opt-out
+  // of the behavior where ethers emits a "block" event for
+  // every block that was missed in between the `pollingInterval`.
+  // We are setting a wait time of 1 as emitting an event in
+  // ethers takes ~0.1ms.
+  const debouncedCallback = debounce(callback, 1);
   let previousProvider;
 
   const createListener = provider => {
-    // We need to debounce the listener as we want to opt-out
-    // of the behavior where ethers emits a "block" event for
-    // every block that was missed in between the `pollingInterval`.
-    // We are setting a wait time of 1 as emitting an event in
-    // ethers takes ~0.1ms.
-    const debouncedCallback = debounce(callback, 1);
-
     if (previousProvider) {
       var _previousProvider;
 
@@ -814,9 +1487,14 @@ function watchBlockNumber(args, callback) {
     previousProvider = provider;
   };
 
-  const client = getClient();
-  const provider_ = (_client$webSocketProv = client.webSocketProvider) !== null && _client$webSocketProv !== void 0 ? _client$webSocketProv : client.provider;
+  const provider_ = getWebSocketProvider({
+    chainId: args.chainId
+  }) ?? getProvider({
+    chainId: args.chainId
+  });
   if (args.listen) createListener(provider_);
+  let active = true;
+  const client = getClient();
   const unsubscribe = client.subscribe(_ref => {
     let {
       provider,
@@ -831,26 +1509,34 @@ function watchBlockNumber(args, callback) {
       provider,
       webSocketProvider
     } = _ref2;
-    const provider_ = webSocketProvider !== null && webSocketProvider !== void 0 ? webSocketProvider : provider;
+    const provider_ = webSocketProvider ?? provider;
 
-    if (args.listen && provider_) {
+    if (args.listen && !args.chainId && provider_) {
       createListener(provider_);
     }
 
-    callback(await fetchBlockNumber());
+    const blockNumber = await fetchBlockNumber({
+      chainId: args.chainId
+    });
+    if (!active) return;
+    callback(blockNumber);
   }, {
     equalityFn: shallow
   });
   return () => {
+    var _previousProvider2;
+
+    active = false;
     unsubscribe();
-    provider_ === null || provider_ === void 0 ? void 0 : provider_.off('block', callback);
+    provider_ === null || provider_ === void 0 ? void 0 : provider_.off('block', debouncedCallback);
+    (_previousProvider2 = previousProvider) === null || _previousProvider2 === void 0 ? void 0 : _previousProvider2.off('block', debouncedCallback);
   };
 }
 
-function watchReadContract(config, callback) {
+function watchMulticall(config, callback) {
   const client = getClient();
 
-  const handleChange = async () => callback(await readContract(config));
+  const handleChange = async () => callback(await multicall(config));
 
   const unwatch = config.listenToBlock ? watchBlockNumber({
     listen: true
@@ -867,10 +1553,10 @@ function watchReadContract(config, callback) {
   };
 }
 
-function watchReadContracts(config, callback) {
+function watchReadContract(config, callback) {
   const client = getClient();
 
-  const handleChange = async () => callback(await readContracts(config));
+  const handleChange = async () => callback(await readContract(config));
 
   const unwatch = config.listenToBlock ? watchBlockNumber({
     listen: true
@@ -887,42 +1573,24 @@ function watchReadContracts(config, callback) {
   };
 }
 
-async function deprecatedSendTransaction(_ref) {
-  let {
-    chainId,
-    request
-  } = _ref;
-  const {
-    connector
-  } = getClient();
-  if (!connector) throw new ConnectorNotFoundError();
-
-  try {
-    var _chain;
-
-    let chain;
-
-    if (chainId) {
-      const activeChainId = await connector.getChainId(); // Try to switch chain to provided `chainId`
-
-      if (chainId !== activeChainId) {
-        var _connector$chains$fin, _connector$chains$fin2, _connector$chains$fin3, _connector$chains$fin4;
+function watchReadContracts(config, callback) {
+  const client = getClient();
 
-        if (connector.switchChain) chain = await connector.switchChain(chainId);else throw new ChainMismatchError({
-          activeChain: (_connector$chains$fin = (_connector$chains$fin2 = connector.chains.find(x => x.id === activeChainId)) === null || _connector$chains$fin2 === void 0 ? void 0 : _connector$chains$fin2.name) !== null && _connector$chains$fin !== void 0 ? _connector$chains$fin : "Chain ".concat(activeChainId),
-          targetChain: (_connector$chains$fin3 = (_connector$chains$fin4 = connector.chains.find(x => x.id === chainId)) === null || _connector$chains$fin4 === void 0 ? void 0 : _connector$chains$fin4.name) !== null && _connector$chains$fin3 !== void 0 ? _connector$chains$fin3 : "Chain ".concat(chainId)
-        });
-      }
-    }
+  const handleChange = async () => callback(await readContracts(config));
 
-    const signer = await connector.getSigner({
-      chainId: (_chain = chain) === null || _chain === void 0 ? void 0 : _chain.id
-    });
-    return await signer.sendTransaction(request);
-  } catch (error) {
-    if (error.code === 4001) throw new UserRejectedRequestError(error);
-    throw error;
-  }
+  const unwatch = config.listenToBlock ? watchBlockNumber({
+    listen: true
+  }, handleChange) : undefined;
+  const unsubscribe = client.subscribe(_ref => {
+    let {
+      provider
+    } = _ref;
+    return provider;
+  }, handleChange);
+  return () => {
+    unsubscribe();
+    unwatch === null || unwatch === void 0 ? void 0 : unwatch();
+  };
 }
 
 /**
@@ -1021,13 +1689,18 @@ async function prepareSendTransaction(_ref) {
   let {
     chainId,
     request,
-    signerOrProvider = getProvider({
-      chainId
-    })
+    signer: signer_
   } = _ref;
+  const signer = signer_ ?? (await fetchSigner({
+    chainId
+  }));
+  if (!signer) throw new ConnectorNotFoundError();
+  if (chainId) assertActiveChain({
+    chainId
+  });
   const [to, gasLimit] = await Promise.all([isAddress(request.to) ? Promise.resolve(request.to) : fetchEnsAddress({
     name: request.to
-  }), request.gasLimit ? Promise.resolve(request.gasLimit) : signerOrProvider.estimateGas(request)]);
+  }), request.gasLimit ? Promise.resolve(request.gasLimit) : signer.estimateGas(request)]);
   if (!to) throw new Error('Could not resolve ENS name');
   return { ...(chainId ? {
       chainId
@@ -1082,20 +1755,9 @@ async function sendTransaction(_ref) {
     if (!request.to) throw new Error('`to` is required');
   }
 
-  const {
-    chain: activeChain,
-    chains
-  } = getNetwork();
-  const activeChainId = activeChain === null || activeChain === void 0 ? void 0 : activeChain.id;
-
-  if (chainId && chainId !== (activeChain === null || activeChain === void 0 ? void 0 : activeChain.id)) {
-    var _chains$find$name, _chains$find, _chains$find$name2, _chains$find2;
-
-    throw new ChainMismatchError({
-      activeChain: (_chains$find$name = (_chains$find = chains.find(x => x.id === activeChainId)) === null || _chains$find === void 0 ? void 0 : _chains$find.name) !== null && _chains$find$name !== void 0 ? _chains$find$name : "Chain ".concat(activeChainId),
-      targetChain: (_chains$find$name2 = (_chains$find2 = chains.find(x => x.id === chainId)) === null || _chains$find2 === void 0 ? void 0 : _chains$find2.name) !== null && _chains$find$name2 !== void 0 ? _chains$find$name2 : "Chain ".concat(chainId)
-    });
-  }
+  if (chainId) assertActiveChain({
+    chainId
+  });
 
   try {
     var _connectUnchecked, _ref2;
@@ -1111,7 +1773,7 @@ async function sendTransaction(_ref) {
     const {
       hash,
       wait
-    } = await (uncheckedSigner !== null && uncheckedSigner !== void 0 ? uncheckedSigner : signer).sendTransaction(request);
+    } = await (uncheckedSigner ?? signer).sendTransaction(request);
     /********************************************************************/
 
     /** END: iOS App Link cautious code.                                */
@@ -1121,7 +1783,7 @@ async function sendTransaction(_ref) {
     /********************************************************************/
 
     return {
-      hash,
+      hash: hash,
       wait
     };
   } catch (error) {
@@ -1160,58 +1822,45 @@ async function waitForTransaction(_ref) {
  * import { prepareWriteContract, writeContract } from '@wagmi/core'
  *
  * const config = await prepareWriteContract({
- *   addressOrName: '0x...',
- *   contractInterface: wagmiAbi,
+ *   address: '0x...',
+ *   abi: wagmiAbi,
  *   functionName: 'mint',
  * })
  * const result = await writeContract(config)
  */
 async function writeContract(_ref) {
   let {
-    addressOrName,
+    address,
     args,
     chainId,
-    contractInterface,
+    abi,
     functionName,
     mode,
     overrides,
     request: request_
   } = _ref;
 
-  /********************************************************************/
+  /****************************************************************************/
 
-  /** START: iOS App Link cautious code.                              */
+  /** START: iOS App Link cautious code.                                      */
 
-  /** Do not perform any async operations in this block.              */
+  /** Do not perform any async operations in this block.                      */
 
-  /** Ref: wagmi.sh/docs/prepare-hooks/intro#ios-app-link-constraints */
+  /** Ref: https://wagmi.sh/docs/prepare-hooks/intro#ios-app-link-constraints */
 
-  /********************************************************************/
+  /****************************************************************************/
   const signer = await fetchSigner();
   if (!signer) throw new ConnectorNotFoundError();
-  const {
-    chain: activeChain,
-    chains
-  } = getNetwork();
-  const activeChainId = activeChain === null || activeChain === void 0 ? void 0 : activeChain.id;
-
-  if (chainId && chainId !== activeChainId) {
-    var _chains$find$name, _chains$find, _chains$find$name2, _chains$find2;
-
-    throw new ChainMismatchError({
-      activeChain: (_chains$find$name = (_chains$find = chains.find(x => x.id === activeChainId)) === null || _chains$find === void 0 ? void 0 : _chains$find.name) !== null && _chains$find$name !== void 0 ? _chains$find$name : "Chain ".concat(activeChainId),
-      targetChain: (_chains$find$name2 = (_chains$find2 = chains.find(x => x.id === chainId)) === null || _chains$find2 === void 0 ? void 0 : _chains$find2.name) !== null && _chains$find$name2 !== void 0 ? _chains$find$name2 : "Chain ".concat(chainId)
-    });
-  }
-
-  if (mode === 'prepared') {
-    if (!request_) throw new Error('`request` is required');
-  }
-
+  if (chainId) assertActiveChain({
+    chainId
+  });
+  if (mode === 'prepared') if (!request_) throw new Error('`request` is required');
   const request = mode === 'recklesslyUnprepared' ? (await prepareWriteContract({
-    addressOrName,
+    address,
     args,
-    contractInterface,
+    chainId,
+    abi: abi,
+    // TODO: Remove cast and still support `Narrow<TAbi>`
     functionName,
     overrides
   })).request : request_;
@@ -1231,7 +1880,7 @@ async function writeContract(_ref) {
 }
 
 async function fetchBalance(_ref) {
-  var _client$chains, _chain$nativeCurrency, _chain$nativeCurrency2, _chain$nativeCurrency3, _chain$nativeCurrency4;
+  var _chain$nativeCurrency, _chain$nativeCurrency2;
 
   let {
     addressOrName,
@@ -1245,47 +1894,78 @@ async function fetchBalance(_ref) {
   });
 
   if (token) {
-    const erc20Config = {
-      addressOrName: token,
-      contractInterface: erc20ABI,
-      chainId
-    }; // Convert ENS name to address if required
-
+    // Convert ENS name to address if required
     let resolvedAddress;
     if (isAddress(addressOrName)) resolvedAddress = addressOrName;else {
       const address = await provider.resolveName(addressOrName); // Same error `provider.getBalance` throws for invalid ENS name
 
       if (!address) logger.throwError('ENS name not configured', Logger.errors.UNSUPPORTED_OPERATION, {
-        operation: "resolveName(".concat(JSON.stringify(addressOrName), ")")
+        operation: `resolveName(${JSON.stringify(addressOrName)})`
       });
       resolvedAddress = address;
     }
-    const [value, decimals, symbol] = await readContracts({
-      allowFailure: false,
-      contracts: [{ ...erc20Config,
-        functionName: 'balanceOf',
-        args: resolvedAddress
-      }, { ...erc20Config,
-        functionName: 'decimals'
-      }, { ...erc20Config,
-        functionName: 'symbol'
-      }]
-    });
-    return {
-      decimals,
-      formatted: formatUnits(value !== null && value !== void 0 ? value : '0', unit !== null && unit !== void 0 ? unit : decimals),
-      symbol,
-      value
+
+    const fetchContractBalance = async _ref2 => {
+      let {
+        abi
+      } = _ref2;
+      const erc20Config = {
+        abi,
+        address: token,
+        chainId
+      };
+      const [value, decimals, symbol] = await readContracts({
+        allowFailure: false,
+        contracts: [{ ...erc20Config,
+          functionName: 'balanceOf',
+          args: [resolvedAddress]
+        }, { ...erc20Config,
+          functionName: 'decimals'
+        }, { ...erc20Config,
+          functionName: 'symbol'
+        }]
+      });
+      return {
+        decimals,
+        formatted: formatUnits(value ?? '0', unit ?? decimals),
+        symbol: symbol,
+        // protect against `ResolvedConfig['BytesType']`
+        value
+      };
     };
+
+    try {
+      return await fetchContractBalance({
+        abi: erc20ABI
+      });
+    } catch (err) {
+      // In the chance that there is an error upon decoding the contract result,
+      // it could be likely that the contract data is represented as bytes32 instead
+      // of a string.
+      if (err instanceof ContractResultDecodeError) {
+        const {
+          symbol,
+          ...rest
+        } = await fetchContractBalance({
+          abi: erc20ABI_bytes32
+        });
+        return {
+          symbol: parseBytes32String(symbol),
+          ...rest
+        };
+      }
+
+      throw err;
+    }
   }
 
-  const chains = [...(client.provider.chains || []), ...((_client$chains = client.chains) !== null && _client$chains !== void 0 ? _client$chains : [])];
+  const chains = [...(client.provider.chains || []), ...(client.chains ?? [])];
   const value = await provider.getBalance(addressOrName);
   const chain = chains.find(x => x.id === provider.network.chainId);
   return {
-    decimals: (_chain$nativeCurrency = chain === null || chain === void 0 ? void 0 : (_chain$nativeCurrency2 = chain.nativeCurrency) === null || _chain$nativeCurrency2 === void 0 ? void 0 : _chain$nativeCurrency2.decimals) !== null && _chain$nativeCurrency !== void 0 ? _chain$nativeCurrency : 18,
-    formatted: formatUnits(value !== null && value !== void 0 ? value : '0', unit !== null && unit !== void 0 ? unit : 'ether'),
-    symbol: (_chain$nativeCurrency3 = chain === null || chain === void 0 ? void 0 : (_chain$nativeCurrency4 = chain.nativeCurrency) === null || _chain$nativeCurrency4 === void 0 ? void 0 : _chain$nativeCurrency4.symbol) !== null && _chain$nativeCurrency3 !== void 0 ? _chain$nativeCurrency3 : 'ETH',
+    decimals: (chain === null || chain === void 0 ? void 0 : (_chain$nativeCurrency = chain.nativeCurrency) === null || _chain$nativeCurrency === void 0 ? void 0 : _chain$nativeCurrency.decimals) ?? 18,
+    formatted: formatUnits(value ?? '0', unit ?? 'ether'),
+    symbol: (chain === null || chain === void 0 ? void 0 : (_chain$nativeCurrency2 = chain.nativeCurrency) === null || _chain$nativeCurrency2 === void 0 ? void 0 : _chain$nativeCurrency2.symbol) ?? 'ETH',
     value
   };
 }
@@ -1293,8 +1973,13 @@ async function fetchBalance(_ref) {
 async function fetchSigner() {
   var _client$connector, _client$connector$get;
 
+  let {
+    chainId
+  } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
   const client = getClient();
-  const signer = (await ((_client$connector = client.connector) === null || _client$connector === void 0 ? void 0 : (_client$connector$get = _client$connector.getSigner) === null || _client$connector$get === void 0 ? void 0 : _client$connector$get.call(_client$connector))) || null;
+  const signer = (await ((_client$connector = client.connector) === null || _client$connector === void 0 ? void 0 : (_client$connector$get = _client$connector.getSigner) === null || _client$connector$get === void 0 ? void 0 : _client$connector$get.call(_client$connector, {
+    chainId
+  }))) || null;
   return signer;
 }
 
@@ -1353,15 +2038,15 @@ function getAccount() {
 }
 
 function getNetwork() {
-  var _client$data, _client$data$chain, _client$chains, _find, _client$data2;
+  var _client$data, _client$data$chain, _client$data2;
 
   const client = getClient();
   const chainId = (_client$data = client.data) === null || _client$data === void 0 ? void 0 : (_client$data$chain = _client$data.chain) === null || _client$data$chain === void 0 ? void 0 : _client$data$chain.id;
-  const activeChains = (_client$chains = client.chains) !== null && _client$chains !== void 0 ? _client$chains : [];
-  const activeChain = (_find = [...(client.provider.chains || []), ...activeChains].find(x => x.id === chainId)) !== null && _find !== void 0 ? _find : {
+  const activeChains = client.chains ?? [];
+  const activeChain = [...(client.provider.chains || []), ...activeChains].find(x => x.id === chainId) ?? {
     id: chainId,
-    name: "Chain ".concat(chainId),
-    network: "".concat(chainId),
+    name: `Chain ${chainId}`,
+    network: `${chainId}`,
     rpcUrls: {
       default: ''
     }
@@ -1394,28 +2079,13 @@ async function signTypedData(_ref) {
   } = _ref;
   const signer = await fetchSigner();
   if (!signer) throw new ConnectorNotFoundError();
-  const {
-    chain: activeChain,
-    chains
-  } = getNetwork();
   const {
     chainId: chainId_
   } = domain;
-
-  if (chainId_) {
-    const chainId = normalizeChainId(chainId_);
-    const activeChainId = activeChain === null || activeChain === void 0 ? void 0 : activeChain.id;
-
-    if (chainId !== (activeChain === null || activeChain === void 0 ? void 0 : activeChain.id)) {
-      var _chains$find$name, _chains$find, _chains$find$name2, _chains$find2;
-
-      throw new ChainMismatchError({
-        activeChain: (_chains$find$name = (_chains$find = chains.find(x => x.id === activeChainId)) === null || _chains$find === void 0 ? void 0 : _chains$find.name) !== null && _chains$find$name !== void 0 ? _chains$find$name : "Chain ".concat(activeChainId),
-        targetChain: (_chains$find$name2 = (_chains$find2 = chains.find(x => x.id === chainId)) === null || _chains$find2 === void 0 ? void 0 : _chains$find2.name) !== null && _chains$find$name2 !== void 0 ? _chains$find$name2 : "Chain ".concat(chainId)
-      });
-    }
-  } // Method name may be changed in the future, see https://docs.ethers.io/v5/api/signer/#Signer-signTypedData
-
+  const chainId = chainId_ ? normalizeChainId(chainId_) : undefined;
+  if (chainId) assertActiveChain({
+    chainId
+  }); // Method name may be changed in the future, see https://docs.ethers.io/v5/api/signer/#Signer-signTypedData
 
   return await signer._signTypedData(domain, types, value);
 }
@@ -1484,18 +2154,23 @@ function watchNetwork(callback) {
   return unsubscribe;
 }
 
-function watchSigner(callback) {
+function watchSigner(_ref, callback) {
+  let {
+    chainId
+  } = _ref;
   const client = getClient();
 
-  const handleChange = async () => callback(await fetchSigner());
+  const handleChange = async () => callback(await fetchSigner({
+    chainId
+  }));
 
-  const unsubscribe = client.subscribe(_ref => {
+  const unsubscribe = client.subscribe(_ref2 => {
     var _data$chain;
 
     let {
       data,
       connector
-    } = _ref;
+    } = _ref2;
     return {
       account: data === null || data === void 0 ? void 0 : data.account,
       chainId: data === null || data === void 0 ? void 0 : (_data$chain = data.chain) === null || _data$chain === void 0 ? void 0 : _data$chain.id,
@@ -1526,4 +2201,4 @@ async function fetchFeeData() {
   };
 }
 
-export { configureChains, connect, deepEqual, deprecatedSendTransaction, deprecatedWriteContract, disconnect, erc20ABI, erc721ABI, fetchBalance, fetchBlockNumber, fetchEnsAddress, fetchEnsAvatar, fetchEnsName, fetchEnsResolver, fetchFeeData, fetchSigner, fetchToken, fetchTransaction, getAccount, getContract, getNetwork, getWebSocketProvider, minimizeContractInterface, parseContractResult, prepareSendTransaction, prepareWriteContract, readContract, readContracts, sendTransaction, signMessage, signTypedData, switchNetwork, units, waitForTransaction, watchAccount, watchBlockNumber, watchContractEvent, watchNetwork, watchProvider, watchReadContract, watchReadContracts, watchSigner, watchWebSocketProvider, writeContract };
+export { configureChains, connect, deepEqual, disconnect, erc20ABI, erc721ABI, fetchBalance, fetchBlockNumber, fetchEnsAddress, fetchEnsAvatar, fetchEnsName, fetchEnsResolver, fetchFeeData, fetchSigner, fetchToken, fetchTransaction, getAccount, getContract, getNetwork, getWebSocketProvider, minimizeContractInterface, multicall, parseContractResult, prepareSendTransaction, prepareWriteContract, readContract, readContracts, sendTransaction, signMessage, signTypedData, switchNetwork, units, waitForTransaction, watchAccount, watchBlockNumber, watchContractEvent, watchMulticall, watchNetwork, watchProvider, watchReadContract, watchReadContracts, watchSigner, watchWebSocketProvider, writeContract };