@wagmi/core 0.2.5 → 0.3.0

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

@@ -1,8 +1,8 @@
-import { providers } from 'ethers';
 import { Mutate, StoreApi } from 'zustand/vanilla';
 import { Connector, ConnectorData } from './connectors';
-import { WagmiStorage } from './storage';
-export declare type ClientConfig<TProvider extends providers.BaseProvider = providers.BaseProvider, TWebSocketProvider extends providers.WebSocketProvider = providers.WebSocketProvider> = {
+import { ClientStorage } from './storage';
+import { Provider, WebSocketProvider } from './types';
+export declare type ClientConfig<TProvider extends Provider = Provider, TWebSocketProvider extends WebSocketProvider = WebSocketProvider> = {
     /** Enables reconnecting to last used connector on init */
     autoConnect?: boolean;
     /**
@@ -23,14 +23,14 @@ export declare type ClientConfig<TProvider extends providers.BaseProvider = prov
      * Custom storage for data persistance
      * @default window.localStorage
      */
-    storage?: WagmiStorage;
+    storage?: ClientStorage;
     /** WebSocket interface for connecting to network */
     webSocketProvider?: ((config: {
         chainId?: number;
     }) => TWebSocketProvider | undefined) | TWebSocketProvider;
 };
-export declare type Data<TProvider extends providers.BaseProvider> = ConnectorData<TProvider>;
-export declare type State<TProvider extends providers.BaseProvider, TWebSocketProvider extends providers.WebSocketProvider = providers.WebSocketProvider> = {
+export declare type Data<TProvider extends Provider> = ConnectorData<TProvider>;
+export declare type State<TProvider extends Provider, TWebSocketProvider extends WebSocketProvider = WebSocketProvider> = {
     chains?: Connector['chains'];
     connector?: Connector;
     connectors: Connector[];
@@ -40,10 +40,10 @@ export declare type State<TProvider extends providers.BaseProvider, TWebSocketPr
     status: 'connected' | 'connecting' | 'reconnecting' | 'disconnected';
     webSocketProvider?: TWebSocketProvider;
 };
-export declare class Client<TProvider extends providers.BaseProvider = providers.BaseProvider, TWebSocketProvider extends providers.WebSocketProvider = providers.WebSocketProvider> {
+export declare class Client<TProvider extends Provider = Provider, TWebSocketProvider extends WebSocketProvider = WebSocketProvider> {
     #private;
     config: Partial<ClientConfig<TProvider, TWebSocketProvider>>;
-    storage: WagmiStorage;
+    storage: ClientStorage;
     store: Mutate<StoreApi<State<TProvider, TWebSocketProvider>>, [
         [
             'zustand/subscribeWithSelector',
@@ -76,6 +76,6 @@ export declare class Client<TProvider extends providers.BaseProvider = providers
     autoConnect(): Promise<Data<TProvider> | undefined>;
     setLastUsedConnector(lastUsedConnector?: string | null): void;
 }
-export declare let client: Client<providers.BaseProvider, providers.WebSocketProvider>;
-export declare function createClient<TProvider extends providers.BaseProvider = providers.BaseProvider, TWebSocketProvider extends providers.WebSocketProvider = providers.WebSocketProvider>(config?: ClientConfig<TProvider, TWebSocketProvider>): Client<TProvider, TWebSocketProvider>;
-export declare function getClient<TProvider extends providers.BaseProvider = providers.BaseProvider, TWebSocketProvider extends providers.WebSocketProvider = providers.WebSocketProvider>(): Client<TProvider, TWebSocketProvider>;
+export declare let client: Client<Provider, WebSocketProvider>;
+export declare function createClient<TProvider extends Provider = Provider, TWebSocketProvider extends WebSocketProvider = WebSocketProvider>(config?: ClientConfig<TProvider, TWebSocketProvider>): Client<TProvider, TWebSocketProvider>;
+export declare function getClient<TProvider extends Provider = Provider, TWebSocketProvider extends WebSocketProvider = WebSocketProvider>(): Client<TProvider, TWebSocketProvider>;

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

@@ -2,6 +2,6 @@ export { erc20ABI, erc721ABI } from './abis';
 export { etherscanBlockExplorers } from './blockExplorers';
 export type { BlockExplorer, BlockExplorerName } from './blockExplorers';
 export { chain, chainId, allChains, defaultChains, defaultL2Chains, } from './chains';
-export { alchemyRpcUrls, infuraRpcUrls } from './rpcs';
+export { alchemyRpcUrls, defaultAlchemyId, infuraRpcUrls, defaultInfuraId, } from './rpcs';
 export type { RpcProviderName } from './rpcs';
 export { units } from './units';

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

@@ -1,3 +1,43 @@
+/**
+ * Error subclass implementing JSON RPC 2.0 errors and Ethereum RPC errors per EIP-1474.
+ * @see https://eips.ethereum.org/EIPS/eip-1474
+ */
+export declare class RpcError<T = undefined> extends Error {
+    readonly code: number;
+    readonly data?: T;
+    readonly internal?: unknown;
+    constructor(
+    /** Number error code */
+    code: number, 
+    /** Human-readable string */
+    message: string, 
+    /** Low-level error */
+    internal?: unknown, 
+    /** Other useful information about error */
+    data?: T);
+}
+/**
+ * Error subclass implementing Ethereum Provider errors per EIP-1193.
+ * @see https://eips.ethereum.org/EIPS/eip-1193
+ */
+export declare class ProviderRpcError<T = undefined> extends RpcError<T> {
+    /**
+     * Create an Ethereum Provider JSON-RPC error.
+     * `code` must be an integer in the 1000 <= 4999 range.
+     */
+    constructor(
+    /**
+     * Number error code
+     * @see https://eips.ethereum.org/EIPS/eip-1193#error-standards
+     */
+    code: 4001 | 4100 | 4200 | 4900 | 4901 | 4902, 
+    /** Human-readable string */
+    message: string, 
+    /** Low-level error */
+    internal?: unknown, 
+    /** Other useful information about error */
+    data?: T);
+}
 export declare class AddChainError extends Error {
     name: string;
     message: string;
@@ -14,15 +54,19 @@ export declare class ConnectorNotFoundError extends Error {
     name: string;
     message: string;
 }
-export declare class SwitchChainError extends Error {
+export declare class SwitchChainError extends ProviderRpcError {
     name: string;
-    message: string;
+    constructor(error: unknown);
 }
 export declare class SwitchChainNotSupportedError extends Error {
     name: string;
     message: string;
 }
-export declare class UserRejectedRequestError extends Error {
+export declare class UserRejectedRequestError extends ProviderRpcError {
     name: string;
-    message: string;
+    constructor(error: unknown);
+}
+export declare class ResourceUnavailableError extends RpcError {
+    name: string;
+    constructor(error: unknown);
 }

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

@@ -1,12 +1,14 @@
 export { connect, disconnect, fetchBalance, fetchBlockNumber, fetchEnsAddress, fetchEnsAvatar, fetchEnsName, fetchEnsResolver, fetchFeeData, fetchSigner, fetchToken, getAccount, getContract, getNetwork, getProvider, getWebSocketProvider, readContract, sendTransaction, signMessage, signTypedData, switchNetwork, waitForTransaction, watchAccount, watchBlockNumber, watchContractEvent, watchNetwork, watchProvider, watchReadContract, watchSigner, watchWebSocketProvider, writeContract, } from './actions';
 export type { ConnectArgs, ConnectResult, FetchBalanceArgs, FetchBalanceResult, FetchBlockNumberArgs, FetchBlockNumberResult, FetchEnsAddressArgs, FetchEnsAddressResult, FetchEnsAvatarArgs, FetchEnsAvatarResult, FetchEnsNameArgs, FetchEnsNameResult, FetchEnsResolverArgs, FetchEnsResolverResult, FetchFeeDataArgs, FetchFeeDataResult, FetchSignerResult, FetchTokenArgs, FetchTokenResult, GetAccountResult, GetContractArgs, GetNetworkResult, GetProviderArgs, GetProviderResult, GetWebSocketProviderArgs, GetWebSocketProviderResult, ReadContractArgs, ReadContractConfig, ReadContractResult, SendTransactionArgs, SendTransactionResult, SignMessageArgs, SignMessageResult, SignTypedDataArgs, SignTypedDataResult, SwitchNetworkArgs, SwitchNetworkResult, WaitForTransactionArgs, WaitForTransactionResult, WatchAccountCallback, WatchBlockNumberArgs, WatchBlockNumberCallback, WatchNetworkCallback, WatchReadContractArgs, WatchReadContractConfig, WatchReadContractResult, WatchSignerCallback, WriteContractArgs, WriteContractConfig, WriteContractResult, } from './actions';
-export { createClient, createClient as createWagmiClient, Client, Client as WagmiClient, } from './client';
-export type { ClientConfig, ClientConfig as WagmiClientConfig } from './client';
+export { configureChains } from './chains';
+export type { ConfigureChainsConfig } from './chains';
+export { createClient, Client } from './client';
+export type { ClientConfig } from './client';
 export { Connector, InjectedConnector } from './connectors';
 export type { ConnectorData, ConnectorEvents } from './connectors';
 export { alchemyRpcUrls, allChains, chain, chainId, defaultChains, defaultL2Chains, erc20ABI, erc721ABI, etherscanBlockExplorers, infuraRpcUrls, units, } from './constants';
-export { AddChainError, ChainNotConfiguredError, ConnectorAlreadyConnectedError, ConnectorNotFoundError, SwitchChainError, SwitchChainNotSupportedError, UserRejectedRequestError, } from './errors';
-export { createStorage, createStorage as createWagmiStorage, noopStorage, } from './storage';
-export type { WagmiStorage as Storage, WagmiStorage } from './storage';
-export type { Chain, Unit } from './types';
+export { AddChainError, ChainNotConfiguredError, ConnectorAlreadyConnectedError, ConnectorNotFoundError, ProviderRpcError, ResourceUnavailableError, RpcError, SwitchChainError, SwitchChainNotSupportedError, UserRejectedRequestError, } from './errors';
+export { createStorage, noopStorage } from './storage';
+export type { ClientStorage as Storage } from './storage';
+export type { Chain, ChainProvider, FallbackProviderConfig, ProviderWithFallbackConfig, Provider, Unit, WebSocketProvider, } from './types';
 export { normalizeChainId } from './utils';

package/dist/declarations/src/providers/alchemy.d.ts

@@ -0,0 +1,7 @@
+import { providers } from 'ethers';
+import { ChainProvider, FallbackProviderConfig } from '../types';
+export declare type AlchemyProviderConfig = FallbackProviderConfig & {
+    alchemyId?: string;
+    pollingInterval?: number;
+};
+export declare function alchemyProvider({ alchemyId, pollingInterval, priority, stallTimeout, weight, }?: AlchemyProviderConfig): ChainProvider<providers.AlchemyProvider, providers.AlchemyWebSocketProvider>;

package/dist/declarations/src/providers/infura.d.ts

@@ -0,0 +1,7 @@
+import { providers } from 'ethers';
+import { ChainProvider, FallbackProviderConfig } from '../types';
+export declare type InfuraProviderConfig = FallbackProviderConfig & {
+    infuraId?: string;
+    pollingInterval?: number;
+};
+export declare function infuraProvider({ infuraId, pollingInterval, priority, stallTimeout, weight, }?: InfuraProviderConfig): ChainProvider<providers.InfuraProvider, providers.InfuraWebSocketProvider>;

package/dist/declarations/src/providers/jsonRpc.d.ts

@@ -0,0 +1,11 @@
+import { providers } from 'ethers';
+import { Chain, ChainProvider, FallbackProviderConfig } from '../types';
+export declare type JsonRpcProviderConfig = FallbackProviderConfig & {
+    pollingInterval?: number;
+    rpc: (chain: Chain) => {
+        http: string;
+        webSocket?: string;
+    } | null;
+    static?: boolean;
+};
+export declare function jsonRpcProvider({ pollingInterval, priority, rpc, stallTimeout, static: static_, weight, }: JsonRpcProviderConfig): ChainProvider<providers.JsonRpcProvider, providers.WebSocketProvider>;

package/dist/declarations/src/providers/public.d.ts

@@ -0,0 +1,6 @@
+import { providers } from 'ethers';
+import { ChainProvider, FallbackProviderConfig } from '../types';
+export declare type PublicProviderConfig = FallbackProviderConfig & {
+    pollingInterval?: number;
+};
+export declare function publicProvider({ pollingInterval, priority, stallTimeout, weight, }?: PublicProviderConfig): ChainProvider<providers.StaticJsonRpcProvider>;

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

@@ -1,5 +1,5 @@
 declare type BaseStorage = Pick<Storage, 'getItem' | 'setItem' | 'removeItem'>;
-export declare type WagmiStorage = {
+export declare type ClientStorage = {
     getItem: <T>(key: string, defaultState?: T | null) => T | null;
     setItem: <T>(key: string, value: T | null) => void;
     removeItem: (key: string) => void;
@@ -8,5 +8,5 @@ export declare const noopStorage: BaseStorage;
 export declare function createStorage({ storage, key: prefix, }: {
     storage: BaseStorage;
     key?: string;
-}): WagmiStorage;
+}): ClientStorage;
 export {};

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

@@ -1,7 +1,9 @@
+import { providers } from 'ethers';
 import { BlockExplorer, BlockExplorerName, RpcProviderName, units } from '../constants';
 export declare type Chain = {
     id: number;
     name: AddEthereumChainParameter['chainName'];
+    network: string;
     nativeCurrency?: AddEthereumChainParameter['nativeCurrency'];
     rpcUrls: {
         [key in RpcProviderName]?: string;
@@ -17,26 +19,43 @@ export declare type Chain = {
     };
     testnet?: boolean;
 };
+export declare type ChainProvider<TProvider extends Provider = Provider, TWebSocketProvider extends WebSocketProvider = WebSocketProvider> = (chain: Chain) => {
+    chain: Chain;
+    provider: () => ProviderWithFallbackConfig<TProvider>;
+    webSocketProvider?: () => TWebSocketProvider;
+} | null;
+export declare type FallbackProviderConfig = Omit<providers.FallbackProviderConfig, 'provider'>;
+export declare type ProviderWithFallbackConfig<TProvider extends Provider = Provider> = TProvider & FallbackProviderConfig;
+export declare type Provider = providers.BaseProvider;
+export declare type WebSocketProvider = providers.WebSocketProvider;
 export declare type Unit = typeof units[number];
 declare global {
     type AddEthereumChainParameter = {
+        /** A 0x-prefixed hexadecimal string */
         chainId: string;
         chainName: string;
         nativeCurrency?: {
             name: string;
+            /** 2-6 characters long */
             symbol: string;
             decimals: number;
         };
         rpcUrls: string[];
         blockExplorerUrls?: string[];
+        /** Currently ignored. */
         iconUrls?: string[];
     };
     type WatchAssetParams = {
+        /** In the future, other standards will be supported */
         type: 'ERC20';
         options: {
+            /** Address of token contract */
             address: string;
+            /** Number of token decimals */
             decimals: number;
+            /** String url of token logo */
             image?: string;
+            /** A ticker symbol or shorthand, up to 5 characters */
             symbol: string;
         };
     };
@@ -69,6 +88,18 @@ declare global {
         on?: (...args: any[]) => void;
         removeListener?: (...args: any[]) => void;
         providers?: Ethereum[];
+        /**
+         * EIP-747: Add wallet_watchAsset to Provider
+         * https://eips.ethereum.org/EIPS/eip-747
+         */
+        request(args: {
+            method: 'wallet_watchAsset';
+            params: WatchAssetParams;
+        }): Promise<boolean>;
+        /**
+         * EIP-1193: Ethereum Provider JavaScript API
+         * https://eips.ethereum.org/EIPS/eip-1193
+         */
         request(args: {
             method: 'eth_accounts';
         }): Promise<string[]>;
@@ -78,34 +109,33 @@ declare global {
         request(args: {
             method: 'eth_requestAccounts';
         }): Promise<string[]>;
+        /**
+         * EIP-1474: Remote procedure call specification
+         * https://eips.ethereum.org/EIPS/eip-1474
+         */
         request(args: {
-            method: 'personal_sign';
-            params: [string, string];
+            method: 'web3_clientVersion';
         }): Promise<string>;
+        /**
+         * EIP-3085: Wallet Add Ethereum Chain RPC Method
+         * https://eips.ethereum.org/EIPS/eip-3085
+         */
         request(args: {
             method: 'wallet_addEthereumChain';
             params: AddEthereumChainParameter[];
         }): Promise<null>;
+        /**
+         * EIP-3326: Wallet Switch Ethereum Chain RPC Method
+         * https://eips.ethereum.org/EIPS/eip-3326
+         */
         request(args: {
             method: 'wallet_switchEthereumChain';
             params: [{
                 chainId: string;
             }];
         }): Promise<null>;
-        request(args: {
-            method: 'wallet_watchAsset';
-            params: WatchAssetParams;
-        }): Promise<boolean>;
-        request(args: {
-            method: 'web3_clientVersion';
-        }): Promise<string>;
     }
     interface Window {
         ethereum?: Ethereum;
     }
-    interface ProviderRpcError extends Error {
-        code: 4001 | 4902;
-        data?: unknown;
-        message: string;
-    }
 }

package/dist/rpcs-7cfbd91c.esm.js

@@ -0,0 +1,30 @@
+const defaultAlchemyId = '_gg7wSSi0KMBsdKnGVfHDueq6xMB9EkC';
+const defaultInfuraId = '84842078b09946638c03157f83405213';
+const alchemyRpcUrls = {
+  mainnet: 'https://eth-mainnet.alchemyapi.io/v2',
+  ropsten: 'https://eth-ropsten.alchemyapi.io/v2',
+  rinkeby: 'https://eth-rinkeby.alchemyapi.io/v2',
+  goerli: 'https://eth-goerli.alchemyapi.io/v2',
+  kovan: 'https://eth-kovan.alchemyapi.io/v2',
+  optimism: 'https://opt-mainnet.g.alchemy.com/v2',
+  optimismKovan: 'https://opt-kovan.g.alchemy.com/v2',
+  polygon: 'https://polygon-mainnet.g.alchemy.com/v2',
+  polygonMumbai: 'https://polygon-mumbai.g.alchemy.com/v2',
+  arbitrum: 'https://arb-mainnet.g.alchemy.com/v2',
+  arbitrumRinkeby: 'https://arb-rinkeby.g.alchemy.com/v2'
+};
+const infuraRpcUrls = {
+  mainnet: 'https://mainnet.infura.io/v3',
+  ropsten: 'https://ropsten.infura.io/v3',
+  rinkeby: 'https://rinkeby.infura.io/v3',
+  goerli: 'https://goerli.infura.io/v3',
+  kovan: 'https://kovan.infura.io/v3',
+  optimism: 'https://optimism-mainnet.infura.io/v3',
+  optimismKovan: 'https://optimism-kovan.infura.io/v3',
+  polygon: 'https://polygon-mainnet.infura.io/v3',
+  polygonMumbai: 'https://polygon-mumbai.infura.io/v3',
+  arbitrum: 'https://arbitrum-mainnet.infura.io/v3',
+  arbitrumRinkeby: 'https://arbitrum-rinkeby.infura.io/v3'
+};
+
+export { alchemyRpcUrls as a, defaultInfuraId as b, defaultAlchemyId as d, infuraRpcUrls as i };

package/dist/rpcs-9c4eb960.cjs.dev.js

@@ -0,0 +1,35 @@
+'use strict';
+
+const defaultAlchemyId = '_gg7wSSi0KMBsdKnGVfHDueq6xMB9EkC';
+const defaultInfuraId = '84842078b09946638c03157f83405213';
+const alchemyRpcUrls = {
+  mainnet: 'https://eth-mainnet.alchemyapi.io/v2',
+  ropsten: 'https://eth-ropsten.alchemyapi.io/v2',
+  rinkeby: 'https://eth-rinkeby.alchemyapi.io/v2',
+  goerli: 'https://eth-goerli.alchemyapi.io/v2',
+  kovan: 'https://eth-kovan.alchemyapi.io/v2',
+  optimism: 'https://opt-mainnet.g.alchemy.com/v2',
+  optimismKovan: 'https://opt-kovan.g.alchemy.com/v2',
+  polygon: 'https://polygon-mainnet.g.alchemy.com/v2',
+  polygonMumbai: 'https://polygon-mumbai.g.alchemy.com/v2',
+  arbitrum: 'https://arb-mainnet.g.alchemy.com/v2',
+  arbitrumRinkeby: 'https://arb-rinkeby.g.alchemy.com/v2'
+};
+const infuraRpcUrls = {
+  mainnet: 'https://mainnet.infura.io/v3',
+  ropsten: 'https://ropsten.infura.io/v3',
+  rinkeby: 'https://rinkeby.infura.io/v3',
+  goerli: 'https://goerli.infura.io/v3',
+  kovan: 'https://kovan.infura.io/v3',
+  optimism: 'https://optimism-mainnet.infura.io/v3',
+  optimismKovan: 'https://optimism-kovan.infura.io/v3',
+  polygon: 'https://polygon-mainnet.infura.io/v3',
+  polygonMumbai: 'https://polygon-mumbai.infura.io/v3',
+  arbitrum: 'https://arbitrum-mainnet.infura.io/v3',
+  arbitrumRinkeby: 'https://arbitrum-rinkeby.infura.io/v3'
+};
+
+exports.alchemyRpcUrls = alchemyRpcUrls;
+exports.defaultAlchemyId = defaultAlchemyId;
+exports.defaultInfuraId = defaultInfuraId;
+exports.infuraRpcUrls = infuraRpcUrls;

package/dist/rpcs-b3c52116.cjs.prod.js

@@ -0,0 +1,35 @@
+'use strict';
+
+const defaultAlchemyId = '_gg7wSSi0KMBsdKnGVfHDueq6xMB9EkC';
+const defaultInfuraId = '84842078b09946638c03157f83405213';
+const alchemyRpcUrls = {
+  mainnet: 'https://eth-mainnet.alchemyapi.io/v2',
+  ropsten: 'https://eth-ropsten.alchemyapi.io/v2',
+  rinkeby: 'https://eth-rinkeby.alchemyapi.io/v2',
+  goerli: 'https://eth-goerli.alchemyapi.io/v2',
+  kovan: 'https://eth-kovan.alchemyapi.io/v2',
+  optimism: 'https://opt-mainnet.g.alchemy.com/v2',
+  optimismKovan: 'https://opt-kovan.g.alchemy.com/v2',
+  polygon: 'https://polygon-mainnet.g.alchemy.com/v2',
+  polygonMumbai: 'https://polygon-mumbai.g.alchemy.com/v2',
+  arbitrum: 'https://arb-mainnet.g.alchemy.com/v2',
+  arbitrumRinkeby: 'https://arb-rinkeby.g.alchemy.com/v2'
+};
+const infuraRpcUrls = {
+  mainnet: 'https://mainnet.infura.io/v3',
+  ropsten: 'https://ropsten.infura.io/v3',
+  rinkeby: 'https://rinkeby.infura.io/v3',
+  goerli: 'https://goerli.infura.io/v3',
+  kovan: 'https://kovan.infura.io/v3',
+  optimism: 'https://optimism-mainnet.infura.io/v3',
+  optimismKovan: 'https://optimism-kovan.infura.io/v3',
+  polygon: 'https://polygon-mainnet.infura.io/v3',
+  polygonMumbai: 'https://polygon-mumbai.infura.io/v3',
+  arbitrum: 'https://arbitrum-mainnet.infura.io/v3',
+  arbitrumRinkeby: 'https://arbitrum-rinkeby.infura.io/v3'
+};
+
+exports.alchemyRpcUrls = alchemyRpcUrls;
+exports.defaultAlchemyId = defaultAlchemyId;
+exports.defaultInfuraId = defaultInfuraId;
+exports.infuraRpcUrls = infuraRpcUrls;

package/dist/wagmi-core.cjs.dev.js

@@ -2,12 +2,12 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var client = require('./client-72d69b8e.cjs.dev.js');
-var base = require('./base-5812b724.cjs.dev.js');
+var client = require('./client-08120ec7.cjs.dev.js');
+var base = require('./base-3a506159.cjs.dev.js');
 var ethers = require('ethers/lib/ethers');
 var utils = require('ethers/lib/utils');
 var ethers$1 = require('ethers');
-require('./classPrivateMethodGet-976c8120.cjs.dev.js');
+var rpcs = require('./rpcs-9c4eb960.cjs.dev.js');
 require('zustand/vanilla');
 require('zustand/middleware');
 require('eventemitter3');
@@ -162,6 +162,7 @@ function getNetwork() {
   const activeChain = (_find = [...activeChains, ...base.allChains].find(x => x.id === chainId)) !== null && _find !== void 0 ? _find : {
     id: chainId,
     name: "Chain ".concat(chainId),
+    network: "".concat(chainId),
     rpcUrls: {
       default: ''
     }
@@ -180,9 +181,8 @@ async function signMessage(args) {
     const signer = await fetchSigner();
     if (!signer) throw new base.ConnectorNotFoundError();
     return await signer.signMessage(args.message);
-  } catch (error_) {
-    let error = error_;
-    if (error_.code === 4001) error = new base.UserRejectedRequestError();
+  } catch (error) {
+    if (error.code === 4001) throw new base.UserRejectedRequestError(error);
     throw error;
   }
 }
@@ -193,9 +193,8 @@ async function signTypedData(args) {
     if (!signer) throw new base.ConnectorNotFoundError(); // Method name may be changed in the future, see https://docs.ethers.io/v5/api/signer/#Signer-signTypedData
 
     return await signer._signTypedData(args.domain, args.types, args.value);
-  } catch (error_) {
-    let error = error_;
-    if (error_.code === 4001) error = new base.UserRejectedRequestError();
+  } catch (error) {
+    if (error.code === 4001) throw new base.UserRejectedRequestError(error);
     throw error;
   }
 }
@@ -371,17 +370,17 @@ async function fetchBlockNumber() {
 function watchBlockNumber(args, callback) {
   var _client$webSocketProv;
 
-  let prevProvider;
+  let previousProvider;
 
   const createListener = provider => {
-    if (prevProvider) {
-      var _prevProvider;
+    if (previousProvider) {
+      var _previousProvider;
 
-      (_prevProvider = prevProvider) === null || _prevProvider === void 0 ? void 0 : _prevProvider.off('block', callback);
+      (_previousProvider = previousProvider) === null || _previousProvider === void 0 ? void 0 : _previousProvider.off('block', callback);
     }
 
     provider.on('block', callback);
-    prevProvider = provider;
+    previousProvider = provider;
   };
 
   const client$1 = client.getClient();
@@ -456,9 +455,8 @@ async function writeContract(contractConfig, functionName) {
     if (!contractFunction) console.warn("\"".concat(functionName, "\" does not exist in interface for contract \"").concat(contractConfig.addressOrName, "\""));
     const response = await contractFunction(...params);
     return response;
-  } catch (error_) {
-    let error = error_;
-    if (error_.code === 4001) error = new base.UserRejectedRequestError();
+  } catch (error) {
+    if (error.code === 4001) throw new base.UserRejectedRequestError(error);
     throw error;
   }
 }
@@ -565,9 +563,8 @@ async function sendTransaction(args) {
     if (!signer) throw new base.ConnectorNotFoundError();
     const transaction = await signer.sendTransaction(args.request);
     return transaction;
-  } catch (error_) {
-    let error = error_;
-    if (error_.code === 4001) error = new base.UserRejectedRequestError();
+  } catch (error) {
+    if (error.code === 4001) throw new base.UserRejectedRequestError(error);
     throw error;
   }
 }
@@ -592,31 +589,133 @@ async function waitForTransaction(_ref) {
   return await promise;
 }
 
+function configureChains(defaultChains, providers) {
+  let {
+    minQuorum = 1,
+    targetQuorum = 1,
+    stallTimeout
+  } = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  if (targetQuorum < minQuorum) throw new Error('quorum cannot be lower than minQuorum');
+  let chains = [];
+  const providers_ = {};
+  const webSocketProviders_ = {};
+
+  for (const chain of defaultChains) {
+    let configExists = false;
+
+    for (const provider of providers) {
+      const apiConfig = provider(chain); // If no API configuration was found (ie. no RPC URL) for
+      // this provider, then we skip and check the next one.
+
+      if (!apiConfig) continue;
+      configExists = true;
+
+      if (!chains.some(_ref => {
+        let {
+          id
+        } = _ref;
+        return id === chain.id;
+      })) {
+        chains = [...chains, apiConfig.chain];
+      }
+
+      providers_[chain.id] = [...(providers_[chain.id] || []), apiConfig.provider];
+
+      if (apiConfig.webSocketProvider) {
+        webSocketProviders_[chain.id] = [...(webSocketProviders_[chain.id] || []), apiConfig.webSocketProvider];
+      }
+    } // If no API configuration was found across the providers
+    // then we throw an error to the consumer.
+
+
+    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'));
+    }
+  }
+
+  return {
+    chains,
+    provider: _ref2 => {
+      let {
+        chainId
+      } = _ref2;
+      const chainProviders = providers_[chainId && chains.some(x => x.id === chainId) ? chainId : defaultChains[0].id];
+      if (chainProviders.length === 1) return chainProviders[0]();
+      return fallbackProvider(targetQuorum, minQuorum, chainProviders, {
+        stallTimeout
+      });
+    },
+    webSocketProvider: _ref3 => {
+      let {
+        chainId
+      } = _ref3;
+      const chainWebSocketProviders = webSocketProviders_[chainId && chains.some(x => x.id === chainId) ? chainId : defaultChains[0].id];
+      if (!chainWebSocketProviders) return undefined;
+      if (chainWebSocketProviders.length === 1) return chainWebSocketProviders[0](); // WebSockets do not work with `fallbackProvider`
+      // Default to first available
+
+      return chainWebSocketProviders[0]();
+    }
+  };
+}
+
+function fallbackProvider(targetQuorum, minQuorum, providers_, _ref4) {
+  let {
+    stallTimeout
+  } = _ref4;
+
+  try {
+    return new ethers$1.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,
+        weight: provider.weight
+      };
+    }), targetQuorum);
+  } catch (error) {
+    var _error$message;
+
+    if (error !== null && error !== void 0 && (_error$message = error.message) !== null && _error$message !== void 0 && _error$message.includes('quorum will always fail; larger than total weight')) {
+      if (targetQuorum === minQuorum) throw error;
+      return fallbackProvider(targetQuorum - 1, minQuorum, providers_, {
+        stallTimeout
+      });
+    }
+
+    throw error;
+  }
+}
+
 exports.Client = client.Client;
 exports.InjectedConnector = client.InjectedConnector;
-exports.WagmiClient = client.Client;
 exports.createClient = client.createClient;
 exports.createStorage = client.createStorage;
-exports.createWagmiClient = client.createClient;
-exports.createWagmiStorage = client.createStorage;
 exports.noopStorage = client.noopStorage;
 exports.AddChainError = base.AddChainError;
 exports.ChainNotConfiguredError = base.ChainNotConfiguredError;
 exports.Connector = base.Connector;
 exports.ConnectorAlreadyConnectedError = base.ConnectorAlreadyConnectedError;
 exports.ConnectorNotFoundError = base.ConnectorNotFoundError;
+exports.ProviderRpcError = base.ProviderRpcError;
+exports.ResourceUnavailableError = base.ResourceUnavailableError;
+exports.RpcError = base.RpcError;
 exports.SwitchChainError = base.SwitchChainError;
 exports.SwitchChainNotSupportedError = base.SwitchChainNotSupportedError;
 exports.UserRejectedRequestError = base.UserRejectedRequestError;
-exports.alchemyRpcUrls = base.alchemyRpcUrls;
 exports.allChains = base.allChains;
 exports.chain = base.chain;
 exports.chainId = base.chainId;
 exports.defaultChains = base.defaultChains;
 exports.defaultL2Chains = base.defaultL2Chains;
 exports.etherscanBlockExplorers = base.etherscanBlockExplorers;
-exports.infuraRpcUrls = base.infuraRpcUrls;
 exports.normalizeChainId = base.normalizeChainId;
+exports.alchemyRpcUrls = rpcs.alchemyRpcUrls;
+exports.infuraRpcUrls = rpcs.infuraRpcUrls;
+exports.configureChains = configureChains;
 exports.connect = connect;
 exports.disconnect = disconnect;
 exports.erc20ABI = erc20ABI;