@wagmi/core 0.2.0-next.8 → 0.2.1

package/dist/{base-82f423a9.esm.js → base-d5bbf720.esm.js}

@@ -113,7 +113,6 @@ const etherscanBlockExplorers = {
 };
 
 const defaultAlchemyId = '_gg7wSSi0KMBsdKnGVfHDueq6xMB9EkC';
-
 const alchemyRpcUrls = {
   mainnet: 'https://eth-mainnet.alchemyapi.io/v2',
   ropsten: 'https://eth-ropsten.alchemyapi.io/v2',
@@ -159,7 +158,7 @@ const chainId = {
 const chain = {
   mainnet: {
     id: chainId.mainnet,
-    name: 'Mainnet',
+    name: 'Ethereum',
     nativeCurrency: {
       name: 'Ether',
       symbol: 'ETH',
@@ -262,7 +261,7 @@ const chain = {
     rpcUrls: {
       alchemy: alchemyRpcUrls.optimism,
       infura: infuraRpcUrls.optimism,
-      default: ['https://mainnet.optimism.io']
+      default: 'https://mainnet.optimism.io'
     },
     blockExplorers: {
       etherscan: etherscanBlockExplorers.optimism,
@@ -280,7 +279,7 @@ const chain = {
     rpcUrls: {
       alchemy: alchemyRpcUrls.optimismKovan,
       infura: infuraRpcUrls.optimismKovan,
-      default: ['https://kovan.optimism.io']
+      default: 'https://kovan.optimism.io'
     },
     blockExplorers: {
       etherscan: etherscanBlockExplorers.optimismKovan,
@@ -290,7 +289,7 @@ const chain = {
   },
   polygon: {
     id: chainId.polygon,
-    name: 'Polygon Mainnet',
+    name: 'Polygon',
     nativeCurrency: {
       name: 'MATIC',
       symbol: 'MATIC',
@@ -299,7 +298,7 @@ const chain = {
     rpcUrls: {
       alchemy: alchemyRpcUrls.polygon,
       infura: infuraRpcUrls.polygon,
-      default: ['https://polygon-rpc.com', 'https://rpc-mainnet.matic.network', 'https://matic-mainnet.chainstacklabs.com', 'https://rpc-mainnet.maticvigil.com', 'https://rpc-mainnet.matic.quiknode.pro', 'https://matic-mainnet-full-rpc.bwarelabs.com']
+      default: 'https://polygon-rpc.com'
     },
     blockExplorers: {
       etherscan: etherscanBlockExplorers.polygon,
@@ -308,7 +307,7 @@ const chain = {
   },
   polygonMumbai: {
     id: chainId.polygonMumbai,
-    name: 'Mumbai',
+    name: 'Polygon Mumbai',
     nativeCurrency: {
       name: 'MATIC',
       symbol: 'MATIC',
@@ -317,7 +316,7 @@ const chain = {
     rpcUrls: {
       alchemy: alchemyRpcUrls.polygonMumbai,
       infura: infuraRpcUrls.polygonMumbai,
-      default: ['https://matic-mumbai.chainstacklabs.com', 'https://rpc-mumbai.maticvigil.com', 'https://matic-testnet-archive-rpc.bwarelabs.com']
+      default: 'https://matic-mumbai.chainstacklabs.com'
     },
     blockExplorers: {
       etherscan: etherscanBlockExplorers.polygonMumbai,
@@ -327,7 +326,7 @@ const chain = {
   },
   arbitrum: {
     id: chainId.arbitrum,
-    name: 'Arbitrum One',
+    name: 'Arbitrum',
     nativeCurrency: {
       name: 'Ether',
       symbol: 'AETH',
@@ -336,14 +335,15 @@ const chain = {
     rpcUrls: {
       alchemy: alchemyRpcUrls.arbitrum,
       infura: infuraRpcUrls.arbitrum,
-      default: ['https://arb1.arbitrum.io/rpc']
+      default: 'https://arb1.arbitrum.io/rpc'
     },
     blockExplorers: {
-      etherscan: etherscanBlockExplorers.arbitrum,
-      default: [etherscanBlockExplorers.arbitrum, {
+      arbitrum: {
         name: 'Arbitrum Explorer',
         url: 'https://explorer.arbitrum.io'
-      }]
+      },
+      etherscan: etherscanBlockExplorers.arbitrum,
+      default: etherscanBlockExplorers.arbitrum
     }
   },
   arbitrumRinkeby: {
@@ -357,14 +357,15 @@ const chain = {
     rpcUrls: {
       alchemy: alchemyRpcUrls.arbitrumRinkeby,
       infura: infuraRpcUrls.arbitrumRinkeby,
-      default: ['https://rinkeby.arbitrum.io/rpc']
+      default: 'https://rinkeby.arbitrum.io/rpc'
     },
     blockExplorers: {
-      etherscan: etherscanBlockExplorers.arbitrumRinkeby,
-      default: [etherscanBlockExplorers.arbitrumRinkeby, {
+      arbitrum: {
         name: 'Arbitrum Explorer',
         url: 'https://rinkeby-explorer.arbitrum.io'
-      }]
+      },
+      etherscan: etherscanBlockExplorers.arbitrumRinkeby,
+      default: etherscanBlockExplorers.arbitrumRinkeby
     },
     testnet: true
   },
@@ -385,6 +386,7 @@ const chain = {
 };
 const allChains = Object.values(chain);
 const defaultChains = [chain.mainnet, chain.ropsten, chain.rinkeby, chain.goerli, chain.kovan];
+const defaultL2Chains = [chain.arbitrum, chain.arbitrumRinkeby, chain.optimism, chain.optimismKovan];
 
 function normalizeChainId(chainId) {
   if (typeof chainId === 'string') return Number.parseInt(chainId, chainId.trim().substring(0, 2) === '0x' ? 16 : 10);
@@ -502,14 +504,10 @@ class Connector extends EventEmitter {
     return [];
   }
 
-  getRpcUrls(chain) {
-    return typeof chain.rpcUrls.default === 'string' ? [chain.rpcUrls.default] : chain.rpcUrls.default;
-  }
-
   isChainUnsupported(chainId) {
     return !this.chains.some(x => x.id === chainId);
   }
 
 }
 
-export { AddChainError as A, Connector as C, SwitchChainError as S, UserRejectedRequestError as U, _defineProperty as _, _classPrivateFieldInitSpec as a, ConnectorNotFoundError as b, _classPrivateFieldSet as c, _classPrivateFieldGet as d, allChains as e, ChainNotConfiguredError as f, ConnectorAlreadyConnectedError as g, SwitchChainNotSupportedError as h, alchemyRpcUrls as i, chain as j, chainId as k, defaultChains as l, etherscanBlockExplorers as m, normalizeChainId as n, infuraRpcUrls as o, _checkPrivateRedeclaration as p };
+export { AddChainError as A, Connector as C, SwitchChainError as S, UserRejectedRequestError as U, _defineProperty as _, _classPrivateFieldInitSpec as a, ConnectorNotFoundError as b, _classPrivateFieldSet as c, _classPrivateFieldGet as d, allChains as e, ChainNotConfiguredError as f, ConnectorAlreadyConnectedError as g, SwitchChainNotSupportedError as h, alchemyRpcUrls as i, chain as j, chainId as k, defaultChains as l, defaultL2Chains as m, normalizeChainId as n, etherscanBlockExplorers as o, infuraRpcUrls as p, _checkPrivateRedeclaration as q };

package/dist/{classPrivateMethodGet-1c660f09.esm.js → classPrivateMethodGet-93a70bfd.esm.js}

@@ -1,4 +1,4 @@
-import { p as _checkPrivateRedeclaration } from './base-82f423a9.esm.js';
+import { q as _checkPrivateRedeclaration } from './base-d5bbf720.esm.js';
 
 function _classPrivateMethodInitSpec(obj, privateSet) {
   _checkPrivateRedeclaration(obj, privateSet);

package/dist/{classPrivateMethodGet-0dc9fedc.cjs.dev.js → classPrivateMethodGet-976c8120.cjs.dev.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var base = require('./base-b3073ce2.cjs.dev.js');
+var base = require('./base-5812b724.cjs.dev.js');
 
 function _classPrivateMethodInitSpec(obj, privateSet) {
   base._checkPrivateRedeclaration(obj, privateSet);

package/dist/{classPrivateMethodGet-c084b176.cjs.prod.js → classPrivateMethodGet-d7330ed7.cjs.prod.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var base = require('./base-7ffc0425.cjs.prod.js');
+var base = require('./base-59f3457e.cjs.prod.js');
 
 function _classPrivateMethodInitSpec(obj, privateSet) {
   base._checkPrivateRedeclaration(obj, privateSet);

package/dist/declarations/src/actions/accounts/connect.d.ts

@@ -1,16 +1,16 @@
-import { BaseProvider } from '@ethersproject/providers';
+import type { BaseProvider } from '@ethersproject/providers';
 import { Client } from '../../client';
 import { Connector, ConnectorData } from '../../connectors';
 export declare type ConnectArgs = {
     /** Connector to connect */
     connector: Connector;
 };
-declare type Data = Required<ConnectorData<BaseProvider>>;
-export declare type ConnectResult = {
-    account: Data['account'];
-    chain: Data['chain'];
-    connector: Client['connector'];
-    provider: Data['provider'];
+declare type Data<TProvider extends BaseProvider = BaseProvider> = Required<ConnectorData<TProvider>>;
+export declare type ConnectResult<TProvider extends BaseProvider = BaseProvider> = {
+    account: Data<TProvider>['account'];
+    chain: Data<TProvider>['chain'];
+    connector: Client<TProvider>['connector'];
+    provider: Data<TProvider>['provider'];
 };
-export declare function connect({ connector, }: ConnectArgs): Promise<ConnectResult>;
+export declare function connect<TProvider extends BaseProvider>({ connector, }: ConnectArgs): Promise<ConnectResult<TProvider>>;
 export {};

package/dist/declarations/src/actions/accounts/fetchBalance.d.ts

@@ -3,6 +3,8 @@ import { Unit } from '../../types';
 export declare type FetchBalanceArgs = {
     /** Address or ENS name */
     addressOrName: string;
+    /** Chain id to use for provider */
+    chainId?: number;
     /** Units for formatting output */
     formatUnits?: Unit | number;
     /** ERC-20 address */
@@ -15,4 +17,4 @@ export declare type FetchBalanceResult = {
     unit: Unit | number;
     value: BigNumber;
 };
-export declare function fetchBalance({ addressOrName, formatUnits: unit, token, }: FetchBalanceArgs): Promise<FetchBalanceResult>;
+export declare function fetchBalance({ addressOrName, chainId, formatUnits: unit, token, }: FetchBalanceArgs): Promise<FetchBalanceResult>;

package/dist/declarations/src/actions/accounts/fetchSigner.d.ts

@@ -1,3 +1,3 @@
 import { Signer } from 'ethers/lib/ethers';
-export declare type FetchSignerResult = Signer | undefined;
+export declare type FetchSignerResult = Signer | null;
 export declare function fetchSigner(): Promise<FetchSignerResult>;

package/dist/declarations/src/actions/accounts/getAccount.d.ts

@@ -1,6 +1,7 @@
+import type { BaseProvider } from '@ethersproject/providers';
 import { Client, Data } from '../../client';
-export declare type GetAccountResult = {
-    address?: Data['account'];
-    connector?: Client['connector'];
+export declare type GetAccountResult<TProvider extends BaseProvider = BaseProvider> = {
+    address?: Data<TProvider>['account'];
+    connector?: Client<TProvider>['connector'];
 };
-export declare function getAccount(): GetAccountResult;
+export declare function getAccount<TProvider extends BaseProvider>(): GetAccountResult<TProvider>;

package/dist/declarations/src/actions/accounts/index.d.ts

@@ -8,6 +8,5 @@ export { signMessage, type SignMessageArgs, type SignMessageResult, } from './si
 export { signTypedData, type SignTypedDataArgs, type SignTypedDataResult, } from './signTypedData';
 export { switchNetwork, type SwitchNetworkArgs, type SwitchNetworkResult, } from './switchNetwork';
 export { watchAccount, type WatchAccountCallback } from './watchAccount';
-export { watchBalance, type WatchBalanceCallback } from './watchBalance';
 export { watchNetwork, type WatchNetworkCallback } from './watchNetwork';
 export { watchSigner, type WatchSignerCallback } from './watchSigner';

package/dist/declarations/src/actions/accounts/watchAccount.d.ts

@@ -1,3 +1,4 @@
+import type { BaseProvider } from '@ethersproject/providers';
 import { GetAccountResult } from './getAccount';
-export declare type WatchAccountCallback = (data: GetAccountResult) => void;
-export declare function watchAccount(callback: WatchAccountCallback): () => void;
+export declare type WatchAccountCallback<TProvider extends BaseProvider = BaseProvider> = (data: GetAccountResult<TProvider>) => void;
+export declare function watchAccount<TProvider extends BaseProvider>(callback: WatchAccountCallback<TProvider>): () => void;

package/dist/declarations/src/actions/contracts/getContract.d.ts

@@ -6,6 +6,6 @@ export declare type GetContractArgs = {
     /** Contract interface or ABI */
     contractInterface: ContractInterface;
     /** Signer or provider to attach to contract */
-    signerOrProvider?: Signer | Provider;
+    signerOrProvider?: Signer | Provider | null;
 };
 export declare function getContract<T = Contract>({ addressOrName, contractInterface, signerOrProvider, }: GetContractArgs): T;

package/dist/declarations/src/actions/contracts/readContract.d.ts

@@ -5,7 +5,10 @@ export declare type ReadContractArgs = GetContractArgs;
 export declare type ReadContractConfig = {
     /** Arguments to pass contract method */
     args?: any | any[];
+    /** Chain id to use for provider */
+    chainId?: number;
+    /** Call overrides */
     overrides?: CallOverrides;
 };
 export declare type ReadContractResult = Result;
-export declare function readContract<Contract extends EthersContract = EthersContract>(contractConfig: ReadContractArgs, functionName: string, { args, overrides }?: ReadContractConfig): Promise<Result>;
+export declare function readContract<Contract extends EthersContract = EthersContract>(contractConfig: ReadContractArgs, functionName: string, { args, chainId, overrides }?: ReadContractConfig): Promise<Result>;

package/dist/declarations/src/actions/contracts/watchContractEvent.d.ts

@@ -1,6 +1,8 @@
 import { Contract as EthersContract } from 'ethers/lib/ethers';
 import { GetContractArgs } from './getContract';
 declare type Config = {
+    /** Chain id to use for provider */
+    chainId?: number;
     /** Receive only a single event */
     once?: boolean;
 };
@@ -8,5 +10,5 @@ export declare function watchContractEvent<Contract extends EthersContract = Eth
 /** Contract configuration */
 contractArgs: GetContractArgs, 
 /** Event name to listen to */
-eventName: Parameters<Contract['on']>[0], callback: Parameters<Contract['on']>[1], { once }?: Config): () => void;
+eventName: Parameters<Contract['on']>[0], callback: Parameters<Contract['on']>[1], { chainId, once }?: Config): () => void;
 export {};

package/dist/declarations/src/actions/ens/fetchEnsAddress.d.ts

@@ -1,6 +1,8 @@
 export declare type FetchEnsAddressArgs = {
+    /** Chain id to use for provider */
+    chainId?: number;
     /** ENS name to resolve */
     name: string;
 };
 export declare type FetchEnsAddressResult = string | null;
-export declare function fetchEnsAddress({ name, }: FetchEnsAddressArgs): Promise<FetchEnsAddressResult>;
+export declare function fetchEnsAddress({ chainId, name, }: FetchEnsAddressArgs): Promise<FetchEnsAddressResult>;

package/dist/declarations/src/actions/ens/fetchEnsAvatar.d.ts

@@ -1,6 +1,8 @@
 export declare type FetchEnsAvatarArgs = {
     /** Address or ENS name */
     addressOrName: string;
+    /** Chain id to use for provider */
+    chainId?: number;
 };
 export declare type FetchEnsAvatarResult = string | null;
-export declare function fetchEnsAvatar({ addressOrName, }: FetchEnsAvatarArgs): Promise<FetchEnsAvatarResult>;
+export declare function fetchEnsAvatar({ addressOrName, chainId, }: FetchEnsAvatarArgs): Promise<FetchEnsAvatarResult>;

package/dist/declarations/src/actions/ens/fetchEnsName.d.ts

@@ -1,6 +1,8 @@
 export declare type FetchEnsNameArgs = {
     /** Address to lookup */
     address: string;
+    /** Chain id to use for provider */
+    chainId?: number;
 };
 export declare type FetchEnsNameResult = string | null;
-export declare function fetchEnsName({ address, }: FetchEnsNameArgs): Promise<FetchEnsNameResult>;
+export declare function fetchEnsName({ address, chainId, }: FetchEnsNameArgs): Promise<FetchEnsNameResult>;

package/dist/declarations/src/actions/ens/fetchEnsResolver.d.ts

@@ -1,7 +1,9 @@
 import type { Resolver } from '@ethersproject/providers';
 export declare type FetchEnsResolverArgs = {
+    /** Chain id to use for provider */
+    chainId?: number;
     /** ENS name to resolve */
     name: string;
 };
 export declare type FetchEnsResolverResult = Resolver | null;
-export declare function fetchEnsResolver({ name, }: FetchEnsResolverArgs): Promise<FetchEnsResolverResult>;
+export declare function fetchEnsResolver({ chainId, name, }: FetchEnsResolverArgs): Promise<FetchEnsResolverResult>;

package/dist/declarations/src/actions/ens/index.d.ts

@@ -2,7 +2,3 @@ export { fetchEnsAddress, type FetchEnsAddressArgs, type FetchEnsAddressResult,
 export { fetchEnsAvatar, type FetchEnsAvatarArgs, type FetchEnsAvatarResult, } from './fetchEnsAvatar';
 export { fetchEnsName, type FetchEnsNameArgs, type FetchEnsNameResult, } from './fetchEnsName';
 export { fetchEnsResolver, type FetchEnsResolverArgs, type FetchEnsResolverResult, } from './fetchEnsResolver';
-export { watchEnsAddress, type WatchEnsAddressCallback, } from './watchEnsAddress';
-export { type WatchEnsAvatarCallback, watchEnsAvatar } from './watchEnsAvatar';
-export { type WatchEnsNameCallback, watchEnsName } from './watchEnsName';
-export { watchEnsResolver, type WatchEnsResolverCallback, } from './watchEnsResolver';

package/dist/declarations/src/actions/index.d.ts

@@ -1,7 +1,7 @@
-export { connect, disconnect, fetchBalance, fetchSigner, getAccount, getNetwork, signMessage, signTypedData, switchNetwork, watchAccount, watchBalance, watchNetwork, watchSigner, type ConnectArgs, type ConnectResult, type FetchBalanceArgs, type FetchBalanceResult, type FetchSignerResult, type GetAccountResult, type GetNetworkResult, type SignMessageArgs, type SignMessageResult, type SignTypedDataArgs, type SignTypedDataResult, type SwitchNetworkArgs, type SwitchNetworkResult, type WatchAccountCallback, type WatchBalanceCallback, type WatchNetworkCallback, type WatchSignerCallback, } from './accounts';
+export { connect, disconnect, fetchBalance, fetchSigner, getAccount, getNetwork, signMessage, signTypedData, switchNetwork, watchAccount, watchNetwork, watchSigner, type ConnectArgs, type ConnectResult, type FetchBalanceArgs, type FetchBalanceResult, type FetchSignerResult, type GetAccountResult, type GetNetworkResult, type SignMessageArgs, type SignMessageResult, type SignTypedDataArgs, type SignTypedDataResult, type SwitchNetworkArgs, type SwitchNetworkResult, type WatchAccountCallback, type WatchNetworkCallback, type WatchSignerCallback, } from './accounts';
 export { getContract, readContract, watchContractEvent, watchReadContract, writeContract, type GetContractArgs, type ReadContractArgs, type ReadContractConfig, type ReadContractResult, type WatchReadContractArgs, type WatchReadContractConfig, type WatchReadContractResult, type WriteContractArgs, type WriteContractConfig, type WriteContractResult, } from './contracts';
-export { fetchEnsAddress, fetchEnsAvatar, fetchEnsName, fetchEnsResolver, watchEnsAddress, watchEnsAvatar, watchEnsName, watchEnsResolver, type FetchEnsAddressArgs, type FetchEnsAddressResult, type FetchEnsAvatarArgs, type FetchEnsAvatarResult, type FetchEnsNameArgs, type FetchEnsNameResult, type FetchEnsResolverArgs, type FetchEnsResolverResult, type WatchEnsAddressCallback, type WatchEnsAvatarCallback, type WatchEnsNameCallback, type WatchEnsResolverCallback, } from './ens';
-export { fetchBlockNumber, fetchFeeData, watchBlockNumber, watchFeeData, type FetchBlockNumberResult, type FetchFeeDataArgs, type FetchFeeDataResult, type WatchBlockNumberArgs, type WatchBlockNumberCallback, type WatchFeeDataArgs, type WatchFeeDataCallback, } from './network-status';
-export { getProvider, getWebSocketProvider, watchProvider, watchWebSocketProvider, type GetProviderResult, type GetWebSocketProviderResult, type WatchProviderCallback, type WatchWebSocketProviderCallback, } from './providers';
-export { fetchToken, watchToken, type FetchTokenArgs, type FetchTokenResult, type WatchTokenCallback, } from './tokens';
+export { fetchEnsAddress, fetchEnsAvatar, fetchEnsName, fetchEnsResolver, type FetchEnsAddressArgs, type FetchEnsAddressResult, type FetchEnsAvatarArgs, type FetchEnsAvatarResult, type FetchEnsNameArgs, type FetchEnsNameResult, type FetchEnsResolverArgs, type FetchEnsResolverResult, } from './ens';
+export { fetchBlockNumber, fetchFeeData, watchBlockNumber, type FetchBlockNumberArgs, type FetchBlockNumberResult, type FetchFeeDataArgs, type FetchFeeDataResult, type WatchBlockNumberArgs, type WatchBlockNumberCallback, } from './network-status';
+export { getProvider, getWebSocketProvider, watchProvider, watchWebSocketProvider, type GetProviderArgs, type GetProviderResult, type GetWebSocketProviderArgs, type GetWebSocketProviderResult, type WatchProviderCallback, type WatchWebSocketProviderCallback, } from './providers';
+export { fetchToken, type FetchTokenArgs, type FetchTokenResult, } from './tokens';
 export { sendTransaction, waitForTransaction, type SendTransactionArgs, type SendTransactionResult, type WaitForTransactionArgs, type WaitForTransactionResult, } from './transactions';

package/dist/declarations/src/actions/network-status/fetchBlockNumber.d.ts

@@ -1,2 +1,5 @@
+export declare type FetchBlockNumberArgs = {
+    chainId?: number;
+};
 export declare type FetchBlockNumberResult = number;
-export declare function fetchBlockNumber(): Promise<number>;
+export declare function fetchBlockNumber({ chainId, }?: FetchBlockNumberArgs): Promise<FetchBlockNumberResult>;

package/dist/declarations/src/actions/network-status/fetchFeeData.d.ts

@@ -3,6 +3,8 @@ import { Unit } from '../../types';
 export declare type FetchFeeDataArgs = {
     /** Units for formatting output */
     formatUnits?: Unit | number;
+    /** Chain id to use for provider */
+    chainId?: number;
 };
 export declare type FetchFeeDataResult = FeeData & {
     formatted: {
@@ -11,4 +13,4 @@ export declare type FetchFeeDataResult = FeeData & {
         maxPriorityFeePerGas: string;
     };
 };
-export declare function fetchFeeData({ formatUnits: units, }?: FetchFeeDataArgs): Promise<FetchFeeDataResult>;
+export declare function fetchFeeData({ chainId, formatUnits: units, }?: FetchFeeDataArgs): Promise<FetchFeeDataResult>;

package/dist/declarations/src/actions/network-status/index.d.ts

@@ -1,4 +1,3 @@
-export { fetchBlockNumber, type FetchBlockNumberResult, } from './fetchBlockNumber';
+export { fetchBlockNumber, type FetchBlockNumberArgs, type FetchBlockNumberResult, } from './fetchBlockNumber';
 export { fetchFeeData, type FetchFeeDataResult, type FetchFeeDataArgs, } from './fetchFeeData';
-export { watchFeeData, type WatchFeeDataArgs, type WatchFeeDataCallback, } from './watchFeeData';
 export { watchBlockNumber, type WatchBlockNumberArgs, type WatchBlockNumberCallback, } from './watchBlockNumber';

package/dist/declarations/src/actions/providers/getProvider.d.ts

@@ -1,3 +1,7 @@
 import type { BaseProvider } from '@ethersproject/providers';
-export declare type GetProviderResult = BaseProvider;
-export declare function getProvider(): GetProviderResult;
+export declare type GetProviderArgs = {
+    /** Chain id to use for provider */
+    chainId?: number;
+};
+export declare type GetProviderResult<TProvider extends BaseProvider = BaseProvider> = TProvider;
+export declare function getProvider<TProvider extends BaseProvider = BaseProvider>({ chainId, }?: GetProviderArgs): GetProviderResult<TProvider>;

package/dist/declarations/src/actions/providers/getWebSocketProvider.d.ts

@@ -1,3 +1,7 @@
 import type { WebSocketProvider } from '@ethersproject/providers';
-export declare type GetWebSocketProviderResult = WebSocketProvider | undefined;
-export declare function getWebSocketProvider(): GetWebSocketProviderResult;
+export declare type GetWebSocketProviderArgs = {
+    /** Chain id to use for provider */
+    chainId?: number;
+};
+export declare type GetWebSocketProviderResult<TWebSocketProvider extends WebSocketProvider = WebSocketProvider> = TWebSocketProvider | undefined;
+export declare function getWebSocketProvider<TWebSocketProvider extends WebSocketProvider = WebSocketProvider>({ chainId, }?: GetWebSocketProviderArgs): GetWebSocketProviderResult<TWebSocketProvider>;

package/dist/declarations/src/actions/providers/index.d.ts

@@ -1,4 +1,4 @@
-export { getProvider, type GetProviderResult } from './getProvider';
-export { getWebSocketProvider, type GetWebSocketProviderResult, } from './getWebSocketProvider';
+export { getProvider, type GetProviderArgs, type GetProviderResult, } from './getProvider';
+export { getWebSocketProvider, type GetWebSocketProviderArgs, type GetWebSocketProviderResult, } from './getWebSocketProvider';
 export { watchProvider, type WatchProviderCallback } from './watchProvider';
 export { watchWebSocketProvider, type WatchWebSocketProviderCallback, } from './watchWebSocketProvider';

package/dist/declarations/src/actions/providers/watchProvider.d.ts

@@ -1,3 +1,4 @@
-import { GetProviderResult } from './getProvider';
-export declare type WatchProviderCallback = (provider: GetProviderResult) => void;
-export declare function watchProvider(callback: WatchProviderCallback): () => void;
+import type { BaseProvider } from '@ethersproject/providers';
+import { GetProviderArgs, GetProviderResult } from './getProvider';
+export declare type WatchProviderCallback<TProvider extends BaseProvider = BaseProvider> = (provider: GetProviderResult<TProvider>) => void;
+export declare function watchProvider<TProvider extends BaseProvider = BaseProvider>(args: GetProviderArgs, callback: WatchProviderCallback<TProvider>): () => void;

package/dist/declarations/src/actions/providers/watchWebSocketProvider.d.ts

@@ -1,3 +1,4 @@
-import { GetWebSocketProviderResult } from './getWebSocketProvider';
-export declare type WatchWebSocketProviderCallback = (webSocketProvider: GetWebSocketProviderResult) => void;
-export declare function watchWebSocketProvider(callback: WatchWebSocketProviderCallback): () => void;
+import type { WebSocketProvider } from '@ethersproject/providers';
+import { GetWebSocketProviderArgs, GetWebSocketProviderResult } from './getWebSocketProvider';
+export declare type WatchWebSocketProviderCallback<TWebSocketProvider extends WebSocketProvider = WebSocketProvider> = (webSocketProvider: GetWebSocketProviderResult<TWebSocketProvider>) => void;
+export declare function watchWebSocketProvider<TWebSocketProvider extends WebSocketProvider = WebSocketProvider>(args: GetWebSocketProviderArgs, callback: WatchWebSocketProviderCallback<TWebSocketProvider>): () => void;

package/dist/declarations/src/actions/tokens/fetchToken.d.ts

@@ -1,7 +1,11 @@
 import { BigNumber } from 'ethers/lib/ethers';
 import { Unit } from '../../types';
 export declare type FetchTokenArgs = {
-    address?: string;
+    /** Address of ERC-20 token */
+    address: string;
+    /** Chain id to use for provider */
+    chainId?: number;
+    /** Units for formatting output */
     formatUnits?: Unit | number;
 };
 export declare type FetchTokenResult = {
@@ -13,12 +17,4 @@ export declare type FetchTokenResult = {
         value: BigNumber;
     };
 };
-export declare function fetchToken({ address, formatUnits: units, }: FetchTokenArgs): Promise<{
-    address: string;
-    decimals: any;
-    symbol: any;
-    totalSupply: {
-        formatted: string;
-        value: any;
-    };
-}>;
+export declare function fetchToken({ address, chainId, formatUnits: units, }: FetchTokenArgs): Promise<FetchTokenResult>;

package/dist/declarations/src/actions/tokens/index.d.ts

@@ -1,2 +1 @@
 export { fetchToken, type FetchTokenArgs, type FetchTokenResult, } from './fetchToken';
-export { watchToken, type WatchTokenCallback } from './watchToken';

package/dist/declarations/src/actions/transactions/waitForTransaction.d.ts

@@ -1,5 +1,7 @@
 import type { TransactionReceipt, TransactionResponse } from '@ethersproject/providers';
 export declare type WaitForTransactionArgs = {
+    /** Chain id to use for provider */
+    chainId?: number;
     /**
      * Number of blocks to wait for after transaction is mined
      * @default 1
@@ -12,4 +14,4 @@ export declare type WaitForTransactionArgs = {
     wait?: TransactionResponse['wait'];
 };
 export declare type WaitForTransactionResult = TransactionReceipt;
-export declare function waitForTransaction(args: WaitForTransactionArgs): Promise<WaitForTransactionResult>;
+export declare function waitForTransaction({ chainId, confirmations, hash, timeout, wait: wait_, }: WaitForTransactionArgs): Promise<WaitForTransactionResult>;

package/dist/declarations/src/client.d.ts

@@ -2,7 +2,7 @@ import type { BaseProvider, WebSocketProvider } from '@ethersproject/providers';
 import { Mutate, StoreApi } from 'zustand/vanilla';
 import { Connector, ConnectorData } from './connectors';
 import { WagmiStorage } from './storage';
-export declare type ClientConfig = {
+export declare type ClientConfig<TProvider extends BaseProvider = BaseProvider, TWebSocketProvider extends WebSocketProvider = WebSocketProvider> = {
     /** Enables reconnecting to last used connector on init */
     autoConnect?: boolean;
     /**
@@ -18,7 +18,7 @@ export declare type ClientConfig = {
      */
     provider?: ((config: {
         chainId?: number;
-    }) => BaseProvider) | BaseProvider;
+    }) => TProvider) | TProvider;
     /**
      * Custom storage for data persistance
      * @default window.localStorage
@@ -27,54 +27,55 @@ export declare type ClientConfig = {
     /** WebSocket interface for connecting to network */
     webSocketProvider?: ((config: {
         chainId?: number;
-    }) => WebSocketProvider | undefined) | WebSocketProvider;
+    }) => TWebSocketProvider | undefined) | TWebSocketProvider;
 };
-export declare type Data = ConnectorData<BaseProvider>;
-export declare type State = {
+export declare type Data<TProvider extends BaseProvider> = ConnectorData<TProvider>;
+export declare type State<TProvider extends BaseProvider, TWebSocketProvider extends WebSocketProvider = WebSocketProvider> = {
     chains?: Connector['chains'];
     connector?: Connector;
     connectors: Connector[];
-    data?: Data;
+    data?: Data<TProvider>;
     error?: Error;
-    provider: BaseProvider;
+    provider: TProvider;
     status: 'connected' | 'connecting' | 'reconnecting' | 'disconnected';
-    webSocketProvider?: WebSocketProvider;
+    webSocketProvider?: TWebSocketProvider;
 };
-export declare class Client {
+export declare class Client<TProvider extends BaseProvider = BaseProvider, TWebSocketProvider extends WebSocketProvider = WebSocketProvider> {
     #private;
-    config: Partial<ClientConfig>;
+    config: Partial<ClientConfig<TProvider, TWebSocketProvider>>;
     storage: WagmiStorage;
-    store: Mutate<StoreApi<State>, [
+    store: Mutate<StoreApi<State<TProvider, TWebSocketProvider>>, [
         [
             'zustand/subscribeWithSelector',
             never
         ],
         [
             'zustand/persist',
-            Partial<State>
+            Partial<State<TProvider, TWebSocketProvider>>
         ]
     ]>;
-    constructor({ autoConnect, connectors, provider, storage, webSocketProvider, }?: ClientConfig);
+    constructor(config?: ClientConfig<TProvider, TWebSocketProvider>);
     get chains(): import("./types").Chain[] | undefined;
     get connectors(): Connector<any, any>[];
     get connector(): Connector<any, any> | undefined;
-    get data(): Data | undefined;
+    get data(): Data<TProvider> | undefined;
     get error(): Error | undefined;
-    get provider(): BaseProvider;
+    get provider(): TProvider;
     get status(): "connecting" | "connected" | "reconnecting" | "disconnected";
     get subscribe(): {
-        (listener: (selectedState: State, previousSelectedState: State) => void): () => void;
-        <U>(selector: (state: State) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
+        (listener: (selectedState: State<TProvider, TWebSocketProvider>, previousSelectedState: State<TProvider, TWebSocketProvider>) => void): () => void;
+        <U>(selector: (state: State<TProvider, TWebSocketProvider>) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
             equalityFn?: ((a: U, b: U) => boolean) | undefined;
             fireImmediately?: boolean | undefined;
         } | undefined): () => void;
     };
-    get webSocketProvider(): WebSocketProvider | undefined;
-    setState(updater: State | ((state: State) => State)): void;
+    get webSocketProvider(): TWebSocketProvider | undefined;
+    setState(updater: State<TProvider, TWebSocketProvider> | ((state: State<TProvider, TWebSocketProvider>) => State<TProvider, TWebSocketProvider>)): void;
     clearState(): void;
     destroy(): Promise<void>;
-    autoConnect(): Promise<Data | undefined>;
+    autoConnect(): Promise<Data<TProvider> | undefined>;
     setLastUsedConnector(lastUsedConnector?: string | null): void;
 }
-export declare let client: Client;
-export declare function createClient(config?: ClientConfig): Client;
+export declare let client: Client<BaseProvider, WebSocketProvider>;
+export declare function createClient<TProvider extends BaseProvider = BaseProvider, TWebSocketProvider extends WebSocketProvider = WebSocketProvider>(config?: ClientConfig<TProvider, TWebSocketProvider>): Client<TProvider, TWebSocketProvider>;
+export declare function getClient<TProvider extends BaseProvider = BaseProvider, TWebSocketProvider extends WebSocketProvider = WebSocketProvider>(): Client<TProvider, TWebSocketProvider>;

package/dist/declarations/src/connectors/base.d.ts

@@ -50,7 +50,6 @@ export declare abstract class Connector<Provider = any, Options = any> extends E
     protected abstract onAccountsChanged(accounts: string[]): void;
     protected abstract onChainChanged(chain: number | string): void;
     protected abstract onDisconnect(error: Error): void;
-    protected getBlockExplorerUrls(chain: Chain): string[];
-    protected getRpcUrls(chain: Chain): string[];
+    protected getBlockExplorerUrls(chain: Chain): any[];
     protected isChainUnsupported(chainId: number): boolean;
 }

package/dist/declarations/src/connectors/injected.d.ts

@@ -25,20 +25,12 @@ export declare class InjectedConnector extends Connector<Window['ethereum'], Inj
             id: number;
             unsupported: boolean;
         };
-        provider: InjectedProviders & {
-            on?: ((...args: any[]) => void) | undefined;
-            removeListener?: ((...args: any[]) => void) | undefined;
-            request<T = any>(args: RequestArguments): Promise<T>;
-        };
+        provider: Ethereum;
     }>;
     disconnect(): Promise<void>;
     getAccount(): Promise<string>;
     getChainId(): Promise<number>;
-    getProvider(): Promise<(InjectedProviders & {
-        on?: ((...args: any[]) => void) | undefined;
-        removeListener?: ((...args: any[]) => void) | undefined;
-        request<T = any>(args: RequestArguments): Promise<T>;
-    }) | undefined>;
+    getProvider(): Promise<Ethereum | undefined>;
     getSigner(): Promise<providers.JsonRpcSigner>;
     isAuthorized(): Promise<boolean>;
     switchChain(chainId: number): Promise<Chain>;

package/dist/declarations/src/connectors/mock/connector.d.ts

@@ -7,7 +7,7 @@ export declare class MockConnector extends Connector<MockProvider, MockProviderO
     readonly name = "Mock";
     readonly ready = true;
     constructor(config: {
-        chains: Chain[];
+        chains?: Chain[];
         options: MockProviderOptions;
     });
     connect(): Promise<{