@wagmi/core 0.4.0-test.2 → 0.4.0

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

@@ -1,20 +1,18 @@
 import { BigNumberish, BytesLike } from 'ethers';
-export interface TypedDataDomain {
-    name?: string;
-    version?: string;
-    chainId?: BigNumberish;
-    verifyingContract?: string;
-    salt?: BytesLike;
-}
-export interface TypedDataField {
-    name: string;
-    type: string;
-}
 export declare type SignTypedDataArgs = {
     /** Domain or domain signature for origin or contract */
-    domain: TypedDataDomain;
+    domain: {
+        name?: string;
+        version?: string;
+        chainId?: BigNumberish;
+        verifyingContract?: string;
+        salt?: BytesLike;
+    };
     /** Named list of all type definitions */
-    types: Record<string, Array<TypedDataField>>;
+    types: Record<string, Array<{
+        name: string;
+        type: string;
+    }>>;
     /** Data to sign */
     value: Record<string, any>;
 };

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

@@ -1,4 +1,12 @@
+import { Connector } from '../../connectors';
 import { Provider } from '../../types';
 import { GetAccountResult } from './getAccount';
 export declare type WatchAccountCallback<TProvider extends Provider = Provider> = (data: GetAccountResult<TProvider>) => void;
-export declare function watchAccount<TProvider extends Provider>(callback: WatchAccountCallback<TProvider>): () => void;
+export declare type WatchAccountConfig = {
+    selector?({ address, connector, status, }: {
+        address?: string;
+        connector?: Connector;
+        status: GetAccountResult['status'];
+    }): any;
+};
+export declare function watchAccount<TProvider extends Provider>(callback: WatchAccountCallback<TProvider>, { selector }?: WatchAccountConfig): () => void;

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

@@ -1,3 +1,10 @@
+import { Chain } from '../../types';
 import { GetNetworkResult } from './getNetwork';
 export declare type WatchNetworkCallback = (data: GetNetworkResult) => void;
-export declare function watchNetwork(callback: WatchNetworkCallback): () => void;
+export declare type WatchNetworkConfig = {
+    selector?({ chainId, chains }: {
+        chainId?: number;
+        chains?: Chain[];
+    }): any;
+};
+export declare function watchNetwork(callback: WatchNetworkCallback, { selector }?: WatchNetworkConfig): () => void;

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

@@ -1,5 +1,7 @@
 export { getContract, type GetContractArgs } from './getContract';
-export { readContract, type ReadContractArgs, type ReadContractConfig, type ReadContractResult, } from './readContract';
+export { readContract, type ReadContractConfig, type ReadContractResult, } from './readContract';
+export { readContracts, type ReadContractsConfig, type ReadContractsResult, } from './readContracts';
 export { watchContractEvent } from './watchContractEvent';
-export { watchReadContract, type WatchReadContractArgs, type WatchReadContractConfig, type WatchReadContractResult, } from './watchReadContract';
-export { writeContract, type WriteContractArgs, type WriteContractConfig, type WriteContractResult, } from './writeContract';
+export { watchReadContract, type WatchReadContractConfig, type WatchReadContractResult, } from './watchReadContract';
+export { watchReadContracts, type WatchReadContractsConfig, type WatchReadContractsResult, } from './watchReadContracts';
+export { writeContract, type WriteContractConfig, type WriteContractResult, } from './writeContract';

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

@@ -0,0 +1,21 @@
+import { CallOverrides } from 'ethers/lib/ethers';
+import { Result } from 'ethers/lib/utils';
+import { ReadContractConfig } from './readContract';
+declare type MulticallContract = {
+    addressOrName: ReadContractConfig['addressOrName'];
+    args?: ReadContractConfig['args'];
+    contractInterface: ReadContractConfig['contractInterface'];
+    functionName: ReadContractConfig['functionName'];
+};
+export declare type MulticallConfig = {
+    /** Failures in the multicall will fail silently */
+    allowFailure?: boolean;
+    /** Chain id to use for provider */
+    chainId?: number;
+    contracts: MulticallContract[];
+    /** Call overrides */
+    overrides?: CallOverrides;
+};
+export declare type MulticallResult<Data extends any[] = Result[]> = Data;
+export declare function multicall<Data extends any[] = Result[]>({ allowFailure, chainId, contracts, overrides, }: MulticallConfig): Promise<MulticallResult<Data>>;
+export {};

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

@@ -1,14 +1,17 @@
-import { CallOverrides, Contract as EthersContract } from 'ethers/lib/ethers';
+import { CallOverrides, Contract } from 'ethers/lib/ethers';
 import { Result } from 'ethers/lib/utils';
 import { GetContractArgs } from './getContract';
-export declare type ReadContractArgs = Pick<GetContractArgs, 'addressOrName' | 'contractInterface'>;
 export declare type ReadContractConfig = {
+    addressOrName: GetContractArgs['addressOrName'];
     /** Arguments to pass contract method */
     args?: any | any[];
     /** Chain id to use for provider */
     chainId?: number;
+    contractInterface: GetContractArgs['contractInterface'];
+    /** Function to invoke on the contract */
+    functionName: string;
     /** Call overrides */
     overrides?: CallOverrides;
 };
-export declare type ReadContractResult = Result;
-export declare function readContract<Contract extends EthersContract = EthersContract>(contractConfig: ReadContractArgs, functionName: string, { args, chainId, overrides }?: ReadContractConfig): Promise<Result>;
+export declare type ReadContractResult<Data = Result> = Data;
+export declare function readContract<TContract extends Contract = Contract, Data = Result>({ addressOrName, args, chainId, contractInterface, functionName, overrides, }: ReadContractConfig): Promise<ReadContractResult<Data>>;

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

@@ -0,0 +1,19 @@
+import { CallOverrides } from 'ethers/lib/ethers';
+import { Result } from 'ethers/lib/utils';
+import { ReadContractConfig } from './readContract';
+export declare type ReadContractsContract = {
+    addressOrName: ReadContractConfig['addressOrName'];
+    args?: ReadContractConfig['args'];
+    chainId?: ReadContractConfig['chainId'];
+    contractInterface: ReadContractConfig['contractInterface'];
+    functionName: ReadContractConfig['functionName'];
+};
+export declare type ReadContractsConfig = {
+    /** Failures will fail silently */
+    allowFailure?: boolean;
+    contracts: ReadContractsContract[];
+    /** Call overrides */
+    overrides?: CallOverrides;
+};
+export declare type ReadContractsResult<Data extends any[] = Result[]> = Data;
+export declare function readContracts<Data extends any[] = Result[]>({ allowFailure, contracts, overrides, }: ReadContractsConfig): Promise<ReadContractsResult<Data>>;

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

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

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

@@ -1,7 +1,6 @@
-import { ReadContractArgs, ReadContractConfig, ReadContractResult } from './readContract';
-export declare type WatchReadContractArgs = ReadContractArgs;
+import { ReadContractConfig, ReadContractResult } from './readContract';
 export declare type WatchReadContractConfig = ReadContractConfig & {
     listenToBlock?: boolean;
 };
 export declare type WatchReadContractResult = (result: ReadContractResult) => void;
-export declare function watchReadContract(contractConfig: WatchReadContractArgs, functionName: string, config: WatchReadContractConfig | undefined, callback: WatchReadContractResult): () => void;
+export declare function watchReadContract(config: WatchReadContractConfig, callback: WatchReadContractResult): () => void;

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

@@ -0,0 +1,6 @@
+import { ReadContractsConfig, ReadContractsResult } from './readContracts';
+export declare type WatchReadContractsConfig = ReadContractsConfig & {
+    listenToBlock?: boolean;
+};
+export declare type WatchReadContractsResult = (result: ReadContractsResult) => void;
+export declare function watchReadContracts(config: WatchReadContractsConfig, callback: WatchReadContractsResult): () => void;

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

@@ -1,10 +1,16 @@
-import { CallOverrides, Contract as EthersContract, providers } from 'ethers';
+import { CallOverrides, Contract, providers } from 'ethers';
 import { GetContractArgs } from './getContract';
-export declare type WriteContractArgs = GetContractArgs;
-export declare type WriteContractConfig = {
+export declare type WriteContractConfig = GetContractArgs & {
+    /**
+     * Chain id to use for write
+     * If signer is not active on this chain, it will attempt to programmatically switch
+     */
+    chainId?: number;
+    /** Method to call on contract */
+    functionName: string;
     /** Arguments to pass contract method */
     args?: any | any[];
     overrides?: CallOverrides;
 };
 export declare type WriteContractResult = providers.TransactionResponse;
-export declare function writeContract<Contract extends EthersContract = EthersContract>(contractConfig: WriteContractArgs, functionName: string, { args, overrides }?: WriteContractConfig): Promise<WriteContractResult>;
+export declare function writeContract<TContract extends Contract = Contract>({ addressOrName, args, chainId, contractInterface, functionName, overrides, signerOrProvider, }: WriteContractConfig): Promise<WriteContractResult>;

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

@@ -1,5 +1,5 @@
 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 { getContract, readContract, readContracts, watchContractEvent, watchReadContract, watchReadContracts, writeContract, type GetContractArgs, type ReadContractConfig, type ReadContractResult, type ReadContractsConfig, type ReadContractsResult, type WatchReadContractConfig, type WatchReadContractResult, type WatchReadContractsConfig, type WatchReadContractsResult, type WriteContractConfig, type WriteContractResult, } from './contracts';
 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';

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

@@ -1,7 +1,12 @@
 import { providers } from 'ethers';
 export declare type SendTransactionArgs = {
+    /**
+     * Chain id to use for write
+     * If signer is not active on this chain, it will attempt to programmatically switch
+     */
+    chainId?: number;
     /** Object to use when creating transaction */
     request: providers.TransactionRequest;
 };
 export declare type SendTransactionResult = providers.TransactionResponse;
-export declare function sendTransaction(args: SendTransactionArgs): Promise<SendTransactionResult>;
+export declare function sendTransaction({ chainId, request, }: SendTransactionArgs): Promise<SendTransactionResult>;

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

@@ -9,14 +9,9 @@ export declare type ClientConfig<TProvider extends Provider = Provider, TWebSock
      * Connectors used for linking accounts
      * @default [new InjectedConnector()]
      */
-    connectors?: ((config: {
-        chainId?: number;
-    }) => Connector[]) | Connector[];
-    /**
-     * Interface for connecting to network
-     * @default (config) => getDefaultProvider(config.chainId)
-     */
-    provider?: ((config: {
+    connectors?: (() => Connector[]) | Connector[];
+    /** Interface for connecting to network */
+    provider: ((config: {
         chainId?: number;
     }) => TProvider) | TProvider;
     /**
@@ -54,7 +49,7 @@ export declare class Client<TProvider extends Provider = Provider, TWebSocketPro
             Partial<State<TProvider, TWebSocketProvider>>
         ]
     ]>;
-    constructor({ autoConnect, connectors, provider, storage, webSocketProvider, }?: ClientConfig<TProvider, TWebSocketProvider>);
+    constructor({ autoConnect, connectors, provider, storage, webSocketProvider, }: ClientConfig<TProvider, TWebSocketProvider>);
     get chains(): import("./types").Chain[] | undefined;
     get connectors(): Connector<any, any>[];
     get connector(): Connector<any, any> | undefined;
@@ -62,7 +57,7 @@ export declare class Client<TProvider extends Provider = Provider, TWebSocketPro
     get error(): Error | undefined;
     get lastUsedChainId(): number | undefined;
     get provider(): TProvider;
-    get status(): "connected" | "connecting" | "reconnecting" | "disconnected";
+    get status(): "connecting" | "connected" | "reconnecting" | "disconnected";
     get subscribe(): {
         (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?: {
@@ -78,5 +73,5 @@ export declare class Client<TProvider extends Provider = Provider, TWebSocketPro
     setLastUsedConnector(lastUsedConnector?: string | null): void;
 }
 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 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/connectors/base.d.ts

@@ -1,5 +1,5 @@
+import { default as EventEmitter } from 'eventemitter3';
 import { Signer } from 'ethers/lib/ethers';
-import { EventEmitter } from '../utils/eventemitter';
 import { Chain } from '../types';
 export declare type ConnectorData<Provider = any> = {
     account?: string;
@@ -42,9 +42,10 @@ export declare abstract class Connector<Provider = any, Options = any> extends E
     abstract getChainId(): Promise<number>;
     abstract getProvider(config?: {
         chainId?: number;
-        create?: boolean;
     }): Promise<Provider>;
-    abstract getSigner(): Promise<Signer>;
+    abstract getSigner(config?: {
+        chainId?: number;
+    }): Promise<Signer>;
     abstract isAuthorized(): Promise<boolean>;
     switchChain?(chainId: number): Promise<Chain>;
     watchAsset?(asset: {

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

@@ -1,5 +1,5 @@
 import { Chain } from '../../types';
-import { Connector } from '../base';
+import { Connector, ConnectorData } from '../base';
 import { MockProvider, MockProviderOptions } from './provider';
 export declare class MockConnector extends Connector<MockProvider, MockProviderOptions> {
     #private;
@@ -12,14 +12,7 @@ export declare class MockConnector extends Connector<MockProvider, MockProviderO
     });
     connect({ chainId }?: {
         chainId?: number;
-    }): Promise<{
-        account: string;
-        chain: {
-            id: number;
-            unsupported: boolean;
-        };
-        provider: MockProvider;
-    }>;
+    }): Promise<Required<ConnectorData<any>>>;
     disconnect(): Promise<void>;
     getAccount(): Promise<string>;
     getChainId(): Promise<number>;

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

@@ -1,3 +1,4 @@
+import { default as EventEmitter } from 'eventemitter3';
 import { Signer, providers } from 'ethers';
 export declare type MockProviderOptions = {
     chainId?: number;
@@ -17,7 +18,7 @@ declare type Events = {
 declare type Event = keyof Events;
 export declare class MockProvider extends providers.BaseProvider {
     #private;
-    events: import("../../utils/eventemitter")<Events, any>;
+    events: EventEmitter<Events, any>;
     constructor(options: MockProviderOptions);
     enable(): Promise<string[]>;
     disconnect(): Promise<void>;

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

@@ -25,11 +25,12 @@ export declare class WalletConnectConnector extends Connector<WalletConnectProvi
     disconnect(): Promise<void>;
     getAccount(): Promise<string>;
     getChainId(): Promise<number>;
-    getProvider({ chainId, create, }?: {
-        chainId?: number | undefined;
-        create?: boolean | undefined;
+    getProvider({ chainId }?: {
+        chainId?: number;
     }): Promise<WalletConnectProvider>;
-    getSigner(): Promise<providers.JsonRpcSigner>;
+    getSigner({ chainId }?: {
+        chainId?: number;
+    }): Promise<providers.JsonRpcSigner>;
     isAuthorized(): Promise<boolean>;
     protected onAccountsChanged: (accounts: string[]) => void;
     protected onChainChanged: (chainId: number | string) => void;

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

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

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

@@ -0,0 +1,25 @@
+export declare const multicallInterface: {
+    inputs: {
+        components: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: {
+        components: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+}[];

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

@@ -1,3 +1,5 @@
+import { Connector } from './connectors';
+import { Chain } from './types';
 /**
  * Error subclass implementing JSON RPC 2.0 errors and Ethereum RPC errors per EIP-1474.
  * @see https://eips.ethereum.org/EIPS/eip-1474
@@ -42,6 +44,20 @@ export declare class AddChainError extends Error {
     name: string;
     message: string;
 }
+export declare class ChainDoesNotSupportMulticallError extends Error {
+    name: string;
+    constructor({ blockNumber, chain }: {
+        blockNumber?: number;
+        chain: Chain;
+    });
+}
+export declare class ChainMismatchError extends Error {
+    name: string;
+    constructor({ activeChain, targetChain, }: {
+        activeChain: string;
+        targetChain: string;
+    });
+}
 export declare class ChainNotConfiguredError extends Error {
     name: string;
     message: string;
@@ -54,19 +70,25 @@ export declare class ConnectorNotFoundError extends Error {
     name: string;
     message: string;
 }
+export declare class ProviderChainsNotFound extends Error {
+    name: string;
+    message: string;
+}
+export declare class ResourceUnavailableError extends RpcError {
+    name: string;
+    constructor(error: unknown);
+}
 export declare class SwitchChainError extends ProviderRpcError {
     name: string;
     constructor(error: unknown);
 }
 export declare class SwitchChainNotSupportedError extends Error {
     name: string;
-    message: string;
+    constructor({ connector }: {
+        connector: Connector;
+    });
 }
 export declare class UserRejectedRequestError extends ProviderRpcError {
     name: string;
     constructor(error: unknown);
 }
-export declare class ResourceUnavailableError extends RpcError {
-    name: string;
-    constructor(error: unknown);
-}

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

@@ -1,13 +1,13 @@
-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 { connect, disconnect, fetchBalance, fetchBlockNumber, fetchEnsAddress, fetchEnsAvatar, fetchEnsName, fetchEnsResolver, fetchFeeData, fetchSigner, fetchToken, getAccount, getContract, getNetwork, getProvider, getWebSocketProvider, readContract, readContracts, sendTransaction, signMessage, signTypedData, switchNetwork, waitForTransaction, watchAccount, watchBlockNumber, watchContractEvent, watchNetwork, watchProvider, watchReadContract, watchReadContracts, 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, ReadContractConfig, ReadContractResult, ReadContractsConfig, ReadContractsResult, SendTransactionArgs, SendTransactionResult, SignMessageArgs, SignMessageResult, SignTypedDataArgs, SignTypedDataResult, SwitchNetworkArgs, SwitchNetworkResult, WaitForTransactionArgs, WaitForTransactionResult, WatchAccountCallback, WatchBlockNumberArgs, WatchBlockNumberCallback, WatchNetworkCallback, WatchReadContractConfig, WatchReadContractResult, WatchProviderCallback, WatchSignerCallback, WatchWebSocketProviderCallback, WriteContractConfig, WriteContractResult, } from './actions';
 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, ProviderRpcError, ResourceUnavailableError, RpcError, SwitchChainError, SwitchChainNotSupportedError, UserRejectedRequestError, } from './errors';
+export { AddChainError, ChainDoesNotSupportMulticallError, ChainMismatchError, ChainNotConfiguredError, ConnectorAlreadyConnectedError, ConnectorNotFoundError, ProviderChainsNotFound, 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 type { Chain, ChainProviderFn, FallbackProviderConfig, ProviderWithFallbackConfig, Provider, Unit, WebSocketProvider, } from './types';
 export { configureChains, normalizeChainId } from './utils';
 export type { ConfigureChainsConfig } from './utils';

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

@@ -1,7 +1,7 @@
 import { providers } from 'ethers';
-import { ChainProvider, FallbackProviderConfig } from '../types';
+import { ChainProviderFn, 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>;
+export declare function alchemyProvider({ alchemyId, pollingInterval, priority, stallTimeout, weight, }?: AlchemyProviderConfig): ChainProviderFn<providers.AlchemyProvider, providers.AlchemyWebSocketProvider>;

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

@@ -1,7 +1,7 @@
 import { providers } from 'ethers';
-import { ChainProvider, FallbackProviderConfig } from '../types';
+import { ChainProviderFn, 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>;
+export declare function infuraProvider({ infuraId, pollingInterval, priority, stallTimeout, weight, }?: InfuraProviderConfig): ChainProviderFn<providers.InfuraProvider, providers.InfuraWebSocketProvider>;

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

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

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

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

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

@@ -7,8 +7,6 @@ export declare type Chain = {
     name: string;
     /** Internal network name */
     network: string;
-    /** ENS registry address */
-    ensAddress?: string;
     /** Currency used by chain */
     nativeCurrency?: AddEthereumChainParameter['nativeCurrency'];
     /** Collection of RPC endpoints */
@@ -25,18 +23,31 @@ export declare type Chain = {
         [key: string]: BlockExplorer;
         default: BlockExplorer;
     };
+    /** ENS registry */
+    ens?: {
+        address: string;
+    };
+    /** Chain multicall contract */
+    multicall?: {
+        address: string;
+        blockCreated: number;
+    };
     /** Flag for test networks */
     testnet?: boolean;
 };
-export declare type ChainProvider<TProvider extends Provider = Provider, TWebSocketProvider extends WebSocketProvider = WebSocketProvider, TChain extends Chain = Chain> = (chain: TChain) => {
+export declare type ChainProviderFn<TProvider extends Provider = Provider, TWebSocketProvider extends WebSocketProvider = WebSocketProvider, TChain extends Chain = Chain> = (chain: TChain) => {
     chain: TChain;
     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 Provider = providers.BaseProvider & {
+    chains?: Chain[];
+};
+export declare type WebSocketProvider = providers.WebSocketProvider & {
+    chains?: Chain[];
+};
 export declare type Unit = typeof units[number];
 declare global {
     type AddEthereumChainParameter = {
@@ -76,6 +87,7 @@ declare global {
         isMetaMask?: true;
         isOpera?: true;
         isTally?: true;
+        isTokenPocket?: true;
         isTokenary?: true;
         isTrust?: true;
     };

package/dist/declarations/src/utils/configureChains.d.ts

@@ -1,5 +1,5 @@
 import { providers } from 'ethers';
-import { Chain, ChainProvider, Provider, WebSocketProvider } from '../types';
+import { Chain, ChainProviderFn, Provider, WebSocketProvider } from '../types';
 export declare type ConfigureChainsConfig = {
     stallTimeout?: number;
 } & ({
@@ -9,12 +9,18 @@ export declare type ConfigureChainsConfig = {
     targetQuorum: number;
     minQuorum?: number;
 });
-export declare function configureChains<TProvider extends Provider = Provider, TWebSocketProvider extends WebSocketProvider = WebSocketProvider, TChain extends Chain = Chain>(defaultChains: TChain[], providers: ChainProvider<TProvider, TWebSocketProvider, TChain>[], { minQuorum, targetQuorum, stallTimeout }?: ConfigureChainsConfig): {
+export declare function configureChains<TProvider extends Provider = Provider, TWebSocketProvider extends WebSocketProvider = WebSocketProvider, TChain extends Chain = Chain>(defaultChains: TChain[], providers: ChainProviderFn<TProvider, TWebSocketProvider, TChain>[], { minQuorum, targetQuorum, stallTimeout }?: ConfigureChainsConfig): {
     readonly chains: TChain[];
     readonly provider: ({ chainId }: {
         chainId?: number | undefined;
-    }) => TProvider | providers.FallbackProvider;
+    }) => (TProvider & {
+        chains: TChain[];
+    }) | (providers.FallbackProvider & {
+        chains: TChain[];
+    });
     readonly webSocketProvider: ({ chainId }: {
         chainId?: number | undefined;
-    }) => TWebSocketProvider | undefined;
+    }) => {
+        chains: TChain[];
+    } | undefined;
 };