wagmi 0.4.11 → 0.5.0

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

@@ -14,6 +14,10 @@ Object.defineProperty(exports, 'arbitrumRinkeby', {
   enumerable: true,
   get: function () { return chains.arbitrumRinkeby; }
 });
+Object.defineProperty(exports, 'foundry', {
+  enumerable: true,
+  get: function () { return chains.foundry; }
+});
 Object.defineProperty(exports, 'goerli', {
   enumerable: true,
   get: function () { return chains.goerli; }

package/chains/dist/wagmi-chains.cjs.prod.js

@@ -14,6 +14,10 @@ Object.defineProperty(exports, 'arbitrumRinkeby', {
   enumerable: true,
   get: function () { return chains.arbitrumRinkeby; }
 });
+Object.defineProperty(exports, 'foundry', {
+  enumerable: true,
+  get: function () { return chains.foundry; }
+});
 Object.defineProperty(exports, 'goerli', {
   enumerable: true,
   get: function () { return chains.goerli; }

package/chains/dist/wagmi-chains.esm.js

@@ -1 +1 @@
-export { arbitrum, arbitrumRinkeby, goerli, hardhat, kovan, localhost, mainnet, optimism, optimismKovan, polygon, polygonMumbai, rinkeby, ropsten } from '@wagmi/core/chains';
+export { arbitrum, arbitrumRinkeby, foundry, goerli, hardhat, kovan, localhost, mainnet, optimism, optimismKovan, polygon, polygonMumbai, rinkeby, ropsten } from '@wagmi/core/chains';

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

@@ -1 +1 @@
-export { arbitrum, arbitrumRinkeby, goerli, hardhat, kovan, localhost, mainnet, optimism, optimismKovan, polygon, polygonMumbai, rinkeby, ropsten, } from '@wagmi/core/chains';
+export { arbitrum, arbitrumRinkeby, foundry, goerli, hardhat, kovan, localhost, mainnet, optimism, optimismKovan, polygon, polygonMumbai, rinkeby, ropsten, } from '@wagmi/core/chains';

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

@@ -6,16 +6,16 @@ export declare type CreateClientConfig<TProvider extends Provider = Provider, TW
     queryClient?: QueryClient;
     persister?: Persister;
 };
-export declare function createClient<TProvider extends Provider, TWebSocketProvider extends WebSocketProvider>({ queryClient, persister, ...config }?: CreateClientConfig<TProvider, TWebSocketProvider>): VanillaClient<TProvider, TWebSocketProvider> & {
+export declare function createClient<TProvider extends Provider, TWebSocketProvider extends WebSocketProvider>({ queryClient, persister, ...config }: CreateClientConfig<TProvider, TWebSocketProvider>): VanillaClient<TProvider, TWebSocketProvider> & {
     queryClient: QueryClient;
 };
 export declare type Client<TProvider extends Provider = Provider, TWebSocketProvider extends WebSocketProvider = WebSocketProvider> = VanillaClient<TProvider, TWebSocketProvider> & {
     queryClient: QueryClient;
 };
-export declare const Context: React.Context<Client<import("@ethersproject/providers").BaseProvider, import("@ethersproject/providers").WebSocketProvider> | undefined>;
+export declare const Context: React.Context<Client<Provider, WebSocketProvider> | undefined>;
 export declare type WagmiConfigProps<TProvider extends Provider = Provider, TWebSocketProvider extends WebSocketProvider = WebSocketProvider> = {
     /** React-decorated Client instance */
-    client?: Client<TProvider, TWebSocketProvider>;
+    client: Client<TProvider, TWebSocketProvider>;
 };
 export declare function WagmiConfig<TProvider extends Provider, TWebSocketProvider extends WebSocketProvider>({ children, client, }: React.PropsWithChildren<WagmiConfigProps<TProvider, TWebSocketProvider>>): JSX.Element;
 export declare function useClient<TProvider extends Provider, TWebSocketProvider extends WebSocketProvider = WebSocketProvider>(): Client<TProvider, TWebSocketProvider>;

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

@@ -6,3 +6,4 @@ export { useNetwork } from './useNetwork';
 export { useSigner } from './useSigner';
 export { useSignMessage } from './useSignMessage';
 export { useSignTypedData } from './useSignTypedData';
+export { useSwitchNetwork } from './useSwitchNetwork';

package/dist/declarations/src/hooks/accounts/useAccount.d.ts

@@ -1,11 +1,12 @@
 import { GetAccountResult } from '@wagmi/core';
-import { QueryConfig } from '../../types';
-export declare type UseAccountConfig = Pick<QueryConfig<GetAccountResult, Error>, 'suspense' | 'onError' | 'onSettled' | 'onSuccess'>;
-export declare const queryKey: () => readonly [{
-    readonly entity: "account";
-}];
-export declare function useAccount({ suspense, onError, onSettled, onSuccess, }?: UseAccountConfig): Pick<import("react-query").QueryObserverResult<GetAccountResult<import("@ethersproject/providers").BaseProvider>, Error>, "data" | "error" | "isError" | "isLoading" | "isSuccess" | "isFetched" | "isFetching" | "isRefetching" | "refetch" | "fetchStatus"> & {
-    isIdle: boolean;
-    status: "error" | "loading" | "success" | "idle";
-    internal: Pick<import("react-query").QueryObserverResult<unknown, unknown>, "isLoadingError" | "isRefetchError" | "dataUpdatedAt" | "errorUpdatedAt" | "failureCount" | "isFetchedAfterMount" | "isPaused" | "isPlaceholderData" | "isPreviousData" | "isStale" | "remove">;
+export declare type UseAccountConfig = {
+    /** Function to invoke when connected */
+    onConnect?({ address, connector, isReconnected, }: {
+        address?: GetAccountResult['address'];
+        connector?: GetAccountResult['connector'];
+        isReconnected: boolean;
+    }): void;
+    /** Function to invoke when disconnected */
+    onDisconnect?(): void;
 };
+export declare function useAccount({ onConnect, onDisconnect }?: UseAccountConfig): GetAccountResult<import("@wagmi/core").Provider>;

package/dist/declarations/src/hooks/accounts/useBalance.d.ts

@@ -14,8 +14,8 @@ export declare const queryKey: ({ addressOrName, chainId, formatUnits, token, }:
     readonly formatUnits: number | "wei" | "kwei" | "mwei" | "gwei" | "szabo" | "finney" | "ether" | undefined;
     readonly token: string | undefined;
 }];
-export declare function useBalance({ addressOrName, cacheTime, chainId: chainId_, enabled, formatUnits, staleTime, suspense, token, watch, onError, onSettled, onSuccess, }?: UseBalanceArgs & UseBalanceConfig): Pick<import("react-query").QueryObserverResult<FetchBalanceResult, Error>, "data" | "error" | "isError" | "isLoading" | "isSuccess" | "isFetched" | "isFetching" | "isRefetching" | "refetch" | "fetchStatus"> & {
+export declare function useBalance({ addressOrName, cacheTime, chainId: chainId_, enabled, formatUnits, staleTime, suspense, token, watch, onError, onSettled, onSuccess, }?: UseBalanceArgs & UseBalanceConfig): Pick<import("react-query").QueryObserverResult<FetchBalanceResult, Error>, "data" | "error" | "fetchStatus" | "isError" | "isFetched" | "isFetching" | "isLoading" | "isRefetching" | "isSuccess" | "refetch"> & {
     isIdle: boolean;
-    status: "error" | "loading" | "success" | "idle";
-    internal: Pick<import("react-query").QueryObserverResult<unknown, unknown>, "isLoadingError" | "isRefetchError" | "dataUpdatedAt" | "errorUpdatedAt" | "failureCount" | "isFetchedAfterMount" | "isPaused" | "isPlaceholderData" | "isPreviousData" | "isStale" | "remove">;
+    status: "error" | "success" | "idle" | "loading";
+    internal: Pick<import("react-query").QueryObserverResult<unknown, unknown>, "dataUpdatedAt" | "errorUpdatedAt" | "failureCount" | "isFetchedAfterMount" | "isLoadingError" | "isPaused" | "isPlaceholderData" | "isPreviousData" | "isRefetchError" | "isStale" | "remove">;
 };

package/dist/declarations/src/hooks/accounts/useConnect.d.ts

@@ -1,42 +1,24 @@
-import { ConnectArgs, ConnectResult, Connector } from '@wagmi/core';
-import { UseMutationOptions } from 'react-query';
+import { ConnectArgs, ConnectResult } from '@wagmi/core';
+import { MutationConfig } from '../../types';
 export declare type UseConnectArgs = Partial<ConnectArgs>;
-declare type MutationOptions = UseMutationOptions<ConnectResult, Error, ConnectArgs>;
-export declare type UseConnectConfig = {
-    /** Chain to connect */
-    chainId?: number;
-    /**
-     * Function to invoke before connect and is passed same variables connect function would receive.
-     * Value returned from this function will be passed to both onError and onSettled functions in event of a mutation failure.
-     */
-    onBeforeConnect?: MutationOptions['onMutate'];
-    /** Function to invoke when connect is successful. */
-    onConnect?: MutationOptions['onSuccess'];
-    /** Function to invoke when an error is thrown while connecting. */
-    onError?: MutationOptions['onError'];
-    /** Function to invoke when connect is settled (either successfully connected, or an error has thrown). */
-    onSettled?: MutationOptions['onSettled'];
-};
-export declare const mutationKey: (args: UseConnectArgs) => {
-    chainId?: number | undefined;
-    connector?: Connector<any, any> | undefined;
-    entity: string;
-}[];
-export declare function useConnect({ chainId, connector, onBeforeConnect, onConnect, onError, onSettled, }?: UseConnectArgs & UseConnectConfig): {
-    readonly activeConnector: Connector<any, any> | undefined;
-    readonly connect: (connectorOrArgs?: Connector<any, any> | Partial<ConnectArgs> | undefined) => void;
-    readonly connectAsync: (connectorOrArgs?: Connector<any, any> | Partial<ConnectArgs> | undefined) => Promise<ConnectResult<import("@ethersproject/providers").BaseProvider>>;
-    readonly connectors: Connector<any, any>[];
-    readonly data: ConnectResult<import("@ethersproject/providers").BaseProvider> | undefined;
+export declare type UseConnectConfig = MutationConfig<ConnectResult, Error, ConnectArgs>;
+export declare const mutationKey: (args: UseConnectArgs) => readonly [{
+    readonly chainId?: number | undefined;
+    readonly connector?: import("@wagmi/core").Connector<any, any> | undefined;
+    readonly entity: "connect";
+}];
+export declare function useConnect({ chainId, connector, onError, onMutate, onSettled, onSuccess, }?: UseConnectArgs & UseConnectConfig): {
+    readonly connect: (args?: Partial<ConnectArgs> | undefined) => void;
+    readonly connectAsync: (args?: Partial<ConnectArgs> | undefined) => Promise<ConnectResult<import("@wagmi/core").Provider>>;
+    readonly connectors: import("@wagmi/core").Connector<any, any>[];
+    readonly data: ConnectResult<import("@wagmi/core").Provider> | undefined;
     readonly error: Error | null;
-    readonly isConnected: boolean;
-    readonly isConnecting: boolean;
-    readonly isDisconnected: boolean;
     readonly isError: boolean;
     readonly isIdle: boolean;
-    readonly isReconnecting: boolean;
-    readonly pendingConnector: Connector<any, any> | undefined;
+    readonly isLoading: boolean;
+    readonly isSuccess: boolean;
+    readonly pendingConnector: import("@wagmi/core").Connector<any, any> | undefined;
     readonly reset: () => void;
-    readonly status: "error" | "connecting" | "connected" | "reconnecting" | "disconnected" | "idle";
+    readonly status: "error" | "success" | "idle" | "loading";
+    readonly variables: ConnectArgs | undefined;
 };
-export {};

package/dist/declarations/src/hooks/accounts/useDisconnect.d.ts

@@ -11,9 +11,9 @@ export declare type UseDisconnectConfig = {
     /** Function fires when mutation is successful and will be passed the mutation's result */
     onSuccess?: (context: unknown) => void | Promise<unknown>;
 };
-export declare const mutationKey: {
-    entity: string;
-}[];
+export declare const mutationKey: readonly [{
+    readonly entity: "disconnect";
+}];
 export declare function useDisconnect({ onError, onMutate, onSettled, onSuccess, }?: UseDisconnectConfig): {
     readonly disconnect: import("react-query").UseMutateFunction<void, Error, void, unknown>;
     readonly disconnectAsync: import("react-query").UseMutateAsyncFunction<void, Error, void, unknown>;
@@ -23,5 +23,5 @@ export declare function useDisconnect({ onError, onMutate, onSettled, onSuccess,
     readonly isLoading: boolean;
     readonly isSuccess: boolean;
     readonly reset: () => void;
-    readonly status: "error" | "loading" | "success" | "idle";
+    readonly status: "error" | "success" | "idle" | "loading";
 };

package/dist/declarations/src/hooks/accounts/useNetwork.d.ts

@@ -1,27 +1 @@
-import { SwitchNetworkArgs, SwitchNetworkResult } from '@wagmi/core';
-import { MutationConfig } from '../../types';
-export declare type UseNetworkArgs = Partial<SwitchNetworkArgs>;
-export declare type UseNetworkConfig = MutationConfig<SwitchNetworkResult, Error, SwitchNetworkArgs>;
-export declare const mutationKey: (args: UseNetworkArgs) => {
-    chainId?: number | undefined;
-    entity: string;
-}[];
-export declare function useNetwork({ chainId, onError, onMutate, onSettled, onSuccess, }?: UseNetworkArgs & UseNetworkConfig): {
-    readonly activeChain: (import("@wagmi/core").Chain & {
-        id: number;
-        unsupported?: boolean | undefined;
-    }) | undefined;
-    readonly chains: import("@wagmi/core").Chain[];
-    readonly data: import("@wagmi/core").Chain | undefined;
-    readonly error: Error | null;
-    readonly isError: boolean;
-    readonly isIdle: boolean;
-    readonly isLoading: boolean;
-    readonly isSuccess: boolean;
-    readonly pendingChainId: number | undefined;
-    readonly reset: () => void;
-    readonly status: "error" | "loading" | "success" | "idle";
-    readonly switchNetwork: ((chainId_?: number | undefined) => void) | undefined;
-    readonly switchNetworkAsync: ((chainId_?: number | undefined) => Promise<import("@wagmi/core").Chain>) | undefined;
-    readonly variables: SwitchNetworkArgs | undefined;
-};
+export declare function useNetwork(): import("@wagmi/core").GetNetworkResult;

package/dist/declarations/src/hooks/accounts/useSignMessage.d.ts

@@ -2,10 +2,10 @@ import { SignMessageArgs, SignMessageResult } from '@wagmi/core';
 import { MutationConfig } from '../../types';
 export declare type UseSignMessageArgs = Partial<SignMessageArgs>;
 export declare type UseSignMessageConfig = MutationConfig<SignMessageResult, Error, SignMessageArgs>;
-export declare const mutationKey: (args: UseSignMessageArgs) => {
-    message?: string | import("ethers").Bytes | undefined;
-    entity: string;
-}[];
+export declare const mutationKey: (args: UseSignMessageArgs) => readonly [{
+    readonly message?: string | import("ethers").Bytes | undefined;
+    readonly entity: "signMessage";
+}];
 export declare function useSignMessage({ message, onError, onMutate, onSettled, onSuccess, }?: UseSignMessageArgs & UseSignMessageConfig): {
     data: string | undefined;
     error: Error | null;
@@ -16,6 +16,6 @@ export declare function useSignMessage({ message, onError, onMutate, onSettled,
     reset: () => void;
     signMessage: (args?: SignMessageArgs | undefined) => void;
     signMessageAsync: (args?: SignMessageArgs | undefined) => Promise<string>;
-    status: "error" | "loading" | "success" | "idle";
+    status: "error" | "success" | "idle" | "loading";
     variables: SignMessageArgs | undefined;
 };

package/dist/declarations/src/hooks/accounts/useSignTypedData.d.ts

@@ -2,12 +2,21 @@ import { SignTypedDataArgs, SignTypedDataResult } from '@wagmi/core';
 import { MutationConfig } from '../../types';
 export declare type UseSignTypedDataArgs = Partial<SignTypedDataArgs>;
 export declare type UseSignTypedDataConfig = MutationConfig<SignTypedDataResult, Error, SignTypedDataArgs>;
-export declare const mutationKey: (args: UseSignTypedDataArgs) => {
-    domain?: import("@wagmi/core/src/actions/accounts/signTypedData").TypedDataDomain | undefined;
-    types?: Record<string, import("@wagmi/core/src/actions/accounts/signTypedData").TypedDataField[]> | undefined;
-    value?: Record<string, any> | undefined;
-    entity: string;
-}[];
+export declare const mutationKey: (args: UseSignTypedDataArgs) => readonly [{
+    readonly domain?: {
+        name?: string | undefined;
+        version?: string | undefined;
+        chainId?: import("ethers").BigNumberish | undefined;
+        verifyingContract?: string | undefined;
+        salt?: import("ethers").BytesLike | undefined;
+    } | undefined;
+    readonly types?: Record<string, {
+        name: string;
+        type: string;
+    }[]> | undefined;
+    readonly value?: Record<string, any> | undefined;
+    readonly entity: "signTypedData";
+}];
 export declare function useSignTypedData({ domain, types, value, onError, onMutate, onSettled, onSuccess, }?: UseSignTypedDataArgs & UseSignTypedDataConfig): {
     data: string | undefined;
     error: Error | null;
@@ -18,6 +27,6 @@ export declare function useSignTypedData({ domain, types, value, onError, onMuta
     reset: () => void;
     signTypedData: (args?: SignTypedDataArgs | undefined) => void;
     signTypedDataAsync: (args?: SignTypedDataArgs | undefined) => Promise<string>;
-    status: "error" | "loading" | "success" | "idle";
+    status: "error" | "success" | "idle" | "loading";
     variables: SignTypedDataArgs | undefined;
 };

package/dist/declarations/src/hooks/accounts/useSigner.d.ts

@@ -4,8 +4,8 @@ export declare type UseSignerConfig = Omit<QueryConfig<FetchSignerResult, Error>
 export declare const queryKey: () => readonly [{
     readonly entity: "signer";
 }];
-export declare function useSigner({ suspense, onError, onSettled, onSuccess, }?: UseSignerConfig): Pick<import("react-query").QueryObserverResult<FetchSignerResult, Error>, "data" | "error" | "isError" | "isLoading" | "isSuccess" | "isFetched" | "isFetching" | "isRefetching" | "refetch" | "fetchStatus"> & {
+export declare function useSigner({ suspense, onError, onSettled, onSuccess, }?: UseSignerConfig): Pick<import("react-query").QueryObserverResult<FetchSignerResult, Error>, "data" | "error" | "fetchStatus" | "isError" | "isFetched" | "isFetching" | "isLoading" | "isRefetching" | "isSuccess" | "refetch"> & {
     isIdle: boolean;
-    status: "error" | "loading" | "success" | "idle";
-    internal: Pick<import("react-query").QueryObserverResult<unknown, unknown>, "isLoadingError" | "isRefetchError" | "dataUpdatedAt" | "errorUpdatedAt" | "failureCount" | "isFetchedAfterMount" | "isPaused" | "isPlaceholderData" | "isPreviousData" | "isStale" | "remove">;
+    status: "error" | "success" | "idle" | "loading";
+    internal: Pick<import("react-query").QueryObserverResult<unknown, unknown>, "dataUpdatedAt" | "errorUpdatedAt" | "failureCount" | "isFetchedAfterMount" | "isLoadingError" | "isPaused" | "isPlaceholderData" | "isPreviousData" | "isRefetchError" | "isStale" | "remove">;
 };

package/dist/declarations/src/hooks/accounts/useSwitchNetwork.d.ts

@@ -0,0 +1,25 @@
+import { SwitchNetworkArgs, SwitchNetworkResult } from '@wagmi/core';
+import { MutationConfig } from '../../types';
+export declare type UseSwitchNetworkArgs = Partial<SwitchNetworkArgs>;
+export declare type UseSwitchNetworkConfig = MutationConfig<SwitchNetworkResult, Error, SwitchNetworkArgs> & {
+    throwForSwitchChainNotSupported?: boolean;
+};
+export declare const mutationKey: (args: UseSwitchNetworkArgs) => readonly [{
+    readonly chainId?: number | undefined;
+    readonly entity: "switchNetwork";
+}];
+export declare function useSwitchNetwork({ chainId, throwForSwitchChainNotSupported, onError, onMutate, onSettled, onSuccess, }?: UseSwitchNetworkArgs & UseSwitchNetworkConfig): {
+    readonly chains: import("@wagmi/core").Chain[];
+    readonly data: import("@wagmi/core").Chain | undefined;
+    readonly error: Error | null;
+    readonly isError: boolean;
+    readonly isIdle: boolean;
+    readonly isLoading: boolean;
+    readonly isSuccess: boolean;
+    readonly pendingChainId: number | undefined;
+    readonly reset: () => void;
+    readonly status: "error" | "success" | "idle" | "loading";
+    readonly switchNetwork: ((chainId_?: number | undefined) => void) | undefined;
+    readonly switchNetworkAsync: ((chainId_?: number | undefined) => Promise<import("@wagmi/core").Chain>) | undefined;
+    readonly variables: SwitchNetworkArgs | undefined;
+};

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

@@ -1,5 +1,7 @@
 export { useContract } from './useContract';
 export { useContractEvent } from './useContractEvent';
+export { useContractInfiniteReads, paginatedIndexesConfig, } from './useContractInfiniteReads';
 export { useContractRead } from './useContractRead';
+export { useContractReads } from './useContractReads';
 export { useContractWrite } from './useContractWrite';
 export { useToken } from './useToken';

package/dist/declarations/src/hooks/contracts/useContractEvent.d.ts

@@ -1,9 +1,13 @@
 import { ethers } from 'ethers';
 import { UseContractConfig } from './useContract';
-export declare type UseContractEventConfig = {
+export declare type UseContractEventConfig<Contract extends ethers.Contract = ethers.Contract> = UseContractConfig & {
+    /** Event name to listen to */
+    eventName: Parameters<Contract['on']>[0];
+    /** Callback function when event is called */
+    listener: Parameters<Contract['on']>[1];
     /** Chain id to use for provider */
     chainId?: number;
     /** Receive only a single event */
     once?: boolean;
 };
-export declare const useContractEvent: <Contract extends ethers.Contract = ethers.Contract>(contractConfig: UseContractConfig, eventName: Parameters<Contract["on"]>[0], listener: Parameters<Contract["on"]>[1], { chainId, once }?: UseContractEventConfig) => void;
+export declare const useContractEvent: <Contract extends ethers.Contract>({ addressOrName, chainId, contractInterface, listener, eventName, signerOrProvider, once, }: UseContractEventConfig<Contract>) => void;

package/dist/declarations/src/hooks/contracts/useContractInfiniteReads.d.ts

@@ -0,0 +1,24 @@
+import { ReadContractResult, ReadContractsConfig } from '@wagmi/core';
+import { InfiniteQueryConfig } from '../../types';
+export declare type UseContractInfiniteReadsConfig<TPageParam = any> = InfiniteQueryConfig<ReadContractResult, Error> & Omit<ReadContractsConfig, 'contracts'> & {
+    cacheKey: string;
+    contracts: (pageParam: TPageParam) => ReadContractsConfig['contracts'];
+};
+export declare const paginatedIndexesConfig: (fn: (index: number) => ReadContractsConfig['contracts'][0], { perPage, start, direction, }: {
+    perPage: number;
+    start: number;
+    direction: 'increment' | 'decrement';
+}) => Pick<UseContractInfiniteReadsConfig<number>, 'contracts' | 'getNextPageParam'>;
+export declare const queryKey: ([{ cacheKey, overrides }]: [{
+    cacheKey: UseContractInfiniteReadsConfig['cacheKey'];
+    overrides: UseContractInfiniteReadsConfig['overrides'];
+}]) => readonly [{
+    readonly entity: "readContractsInfinite";
+    readonly cacheKey: string;
+    readonly overrides: import("ethers").CallOverrides | undefined;
+}];
+export declare function useContractInfiniteReads<TPageParam = any>({ cacheKey, cacheTime, contracts, enabled: enabled_, getNextPageParam, keepPreviousData, onError, onSettled, onSuccess, overrides, select, staleTime, suspense, }: UseContractInfiniteReadsConfig<TPageParam>): Pick<import("react-query").InfiniteQueryObserverResult<import("ethers/lib/utils").Result, Error>, "data" | "error" | "fetchStatus" | "isError" | "isFetched" | "isFetching" | "isLoading" | "isRefetching" | "isSuccess" | "refetch" | "fetchNextPage" | "hasNextPage" | "isFetchingNextPage"> & {
+    isIdle: boolean;
+    status: "error" | "success" | "idle" | "loading";
+    internal: Pick<import("react-query").InfiniteQueryObserverResult<unknown, unknown>, "dataUpdatedAt" | "errorUpdatedAt" | "failureCount" | "isFetchedAfterMount" | "isLoadingError" | "isPaused" | "isPlaceholderData" | "isPreviousData" | "isRefetchError" | "isStale" | "remove">;
+};

package/dist/declarations/src/hooks/contracts/useContractRead.d.ts

@@ -1,26 +1,27 @@
-import { ReadContractArgs, ReadContractConfig, ReadContractResult } from '@wagmi/core';
+import { ReadContractConfig, ReadContractResult } from '@wagmi/core';
 import { QueryConfig } from '../../types';
-declare type UseContractReadArgs = Partial<ReadContractConfig> & {
+declare type UseContractReadArgs = ReadContractConfig & {
     /** If set to `true`, the cache will depend on the block number */
     cacheOnBlock?: boolean;
     /** Subscribe to changes */
     watch?: boolean;
 };
 export declare type UseContractReadConfig = QueryConfig<ReadContractResult, Error>;
-export declare const queryKey: ([contractConfig, functionName, { args, chainId, overrides }, { blockNumber },]: [ReadContractArgs, string, Partial<ReadContractConfig>, {
+export declare const queryKey: ([{ addressOrName, args, chainId, contractInterface, functionName, overrides }, { blockNumber },]: [ReadContractConfig, {
     blockNumber?: number | undefined;
 }]) => readonly [{
     readonly entity: "readContract";
+    readonly addressOrName: string;
     readonly args: any;
     readonly blockNumber: number | undefined;
     readonly chainId: number | undefined;
-    readonly contractConfig: ReadContractArgs;
+    readonly contractInterface: import("ethers").ContractInterface;
     readonly functionName: string;
     readonly overrides: import("ethers").CallOverrides | undefined;
 }];
-export declare function useContractRead(contractConfig: ReadContractArgs, functionName: string, { args, chainId: chainId_, overrides, cacheOnBlock, cacheTime, enabled: enabled_, staleTime, suspense, watch, onError, onSettled, onSuccess, }?: UseContractReadArgs & UseContractReadConfig): Pick<import("react-query").QueryObserverResult<import("ethers/lib/utils").Result, Error>, "data" | "error" | "isError" | "isLoading" | "isSuccess" | "isFetched" | "isFetching" | "isRefetching" | "refetch" | "fetchStatus"> & {
+export declare function useContractRead({ addressOrName, contractInterface, functionName, args, chainId: chainId_, overrides, cacheOnBlock, cacheTime, enabled: enabled_, select, staleTime, suspense, watch, onError, onSettled, onSuccess, }: UseContractReadArgs & UseContractReadConfig): Pick<import("react-query").QueryObserverResult<import("ethers/lib/utils").Result, Error>, "data" | "error" | "fetchStatus" | "isError" | "isFetched" | "isFetching" | "isLoading" | "isRefetching" | "isSuccess" | "refetch"> & {
     isIdle: boolean;
-    status: "error" | "loading" | "success" | "idle";
-    internal: Pick<import("react-query").QueryObserverResult<unknown, unknown>, "isLoadingError" | "isRefetchError" | "dataUpdatedAt" | "errorUpdatedAt" | "failureCount" | "isFetchedAfterMount" | "isPaused" | "isPlaceholderData" | "isPreviousData" | "isStale" | "remove">;
+    status: "error" | "success" | "idle" | "loading";
+    internal: Pick<import("react-query").QueryObserverResult<unknown, unknown>, "dataUpdatedAt" | "errorUpdatedAt" | "failureCount" | "isFetchedAfterMount" | "isLoadingError" | "isPaused" | "isPlaceholderData" | "isPreviousData" | "isRefetchError" | "isStale" | "remove">;
 };
 export {};

package/dist/declarations/src/hooks/contracts/useContractReads.d.ts

@@ -0,0 +1,21 @@
+import { ReadContractsConfig, ReadContractsResult } from '@wagmi/core';
+import { QueryConfig } from '../../types';
+export declare type UseContractReadsConfig = QueryConfig<ReadContractsResult, Error> & ReadContractsConfig & {
+    /** If set to `true`, the cache will depend on the block number */
+    cacheOnBlock?: boolean;
+    /** Subscribe to changes */
+    watch?: boolean;
+};
+export declare const queryKey: ([{ contracts, overrides }, { blockNumber }]: [ReadContractsConfig, {
+    blockNumber?: number | undefined;
+}]) => readonly [{
+    readonly entity: "readContracts";
+    readonly contracts: import("@wagmi/core/src/actions/contracts/readContracts").ReadContractsContract[];
+    readonly blockNumber: number | undefined;
+    readonly overrides: import("ethers").CallOverrides | undefined;
+}];
+export declare function useContractReads({ cacheOnBlock, cacheTime, contracts, overrides, enabled: enabled_, keepPreviousData, onError, onSettled, onSuccess, select, staleTime, suspense, watch, }: UseContractReadsConfig): Pick<import("react-query").QueryObserverResult<import("ethers/lib/utils").Result[], Error>, "data" | "error" | "fetchStatus" | "isError" | "isFetched" | "isFetching" | "isLoading" | "isRefetching" | "isSuccess" | "refetch"> & {
+    isIdle: boolean;
+    status: "error" | "success" | "idle" | "loading";
+    internal: Pick<import("react-query").QueryObserverResult<unknown, unknown>, "dataUpdatedAt" | "errorUpdatedAt" | "failureCount" | "isFetchedAfterMount" | "isLoadingError" | "isPaused" | "isPlaceholderData" | "isPreviousData" | "isRefetchError" | "isStale" | "remove">;
+};

package/dist/declarations/src/hooks/contracts/useContractWrite.d.ts

@@ -1,15 +1,17 @@
-import { WriteContractArgs, WriteContractConfig, WriteContractResult } from '@wagmi/core';
+import { WriteContractConfig, WriteContractResult } from '@wagmi/core';
 import { MutationConfig } from '../../types';
-export declare type UseContractWriteArgs = Partial<WriteContractConfig>;
+export declare type UseContractWriteArgs = WriteContractConfig;
+export declare type UseContractWriteMutationArgs = Pick<WriteContractConfig, 'args' | 'overrides'>;
 export declare type UseContractWriteConfig = MutationConfig<WriteContractResult, Error, UseContractWriteArgs>;
-export declare const mutationKey: ([contractConfig, functionName, { args, overrides },]: [WriteContractArgs, string, Partial<WriteContractConfig>]) => readonly [{
+export declare const mutationKey: ([{ addressOrName, args, chainId, contractInterface, overrides },]: [WriteContractConfig]) => readonly [{
     readonly entity: "writeContract";
+    readonly addressOrName: string;
     readonly args: any;
-    readonly contractConfig: import("@wagmi/core").GetContractArgs;
-    readonly functionName: string;
+    readonly chainId: number | undefined;
+    readonly contractInterface: import("ethers").ContractInterface;
     readonly overrides: import("ethers").CallOverrides | undefined;
 }];
-export declare function useContractWrite(contractConfig: WriteContractArgs, functionName: string, { args, overrides, onError, onMutate, onSettled, onSuccess, }?: UseContractWriteArgs & UseContractWriteConfig): {
+export declare function useContractWrite({ addressOrName, args, chainId, contractInterface, functionName, overrides, signerOrProvider, onError, onMutate, onSettled, onSuccess, }: UseContractWriteArgs & UseContractWriteConfig): {
     data: import("@ethersproject/providers").TransactionResponse | undefined;
     error: Error | null;
     isError: boolean;
@@ -17,8 +19,8 @@ export declare function useContractWrite(contractConfig: WriteContractArgs, func
     isLoading: boolean;
     isSuccess: boolean;
     reset: () => void;
-    status: "error" | "loading" | "success" | "idle";
-    variables: Partial<WriteContractConfig> | undefined;
-    write: (overrideConfig?: WriteContractConfig | undefined) => void;
-    writeAsync: (overrideConfig?: WriteContractConfig | undefined) => Promise<import("@ethersproject/providers").TransactionResponse>;
+    status: "error" | "success" | "idle" | "loading";
+    variables: WriteContractConfig | undefined;
+    write: (overrideConfig?: UseContractWriteMutationArgs | undefined) => void;
+    writeAsync: (overrideConfig?: UseContractWriteMutationArgs | undefined) => Promise<import("@ethersproject/providers").TransactionResponse>;
 };

package/dist/declarations/src/hooks/contracts/useToken.d.ts

@@ -11,8 +11,8 @@ export declare const queryKey: ({ address, chainId, formatUnits, }: Partial<Fetc
     readonly formatUnits: number | "wei" | "kwei" | "mwei" | "gwei" | "szabo" | "finney" | "ether" | undefined;
 }];
 export declare function useToken({ address, chainId: chainId_, formatUnits, cacheTime, enabled, staleTime, // 24 hours
-suspense, onError, onSettled, onSuccess, }?: UseTokenArgs & UseTokenConfig): Pick<import("react-query").QueryObserverResult<FetchTokenResult, Error>, "data" | "error" | "isError" | "isLoading" | "isSuccess" | "isFetched" | "isFetching" | "isRefetching" | "refetch" | "fetchStatus"> & {
+suspense, onError, onSettled, onSuccess, }?: UseTokenArgs & UseTokenConfig): Pick<import("react-query").QueryObserverResult<FetchTokenResult, Error>, "data" | "error" | "fetchStatus" | "isError" | "isFetched" | "isFetching" | "isLoading" | "isRefetching" | "isSuccess" | "refetch"> & {
     isIdle: boolean;
-    status: "error" | "loading" | "success" | "idle";
-    internal: Pick<import("react-query").QueryObserverResult<unknown, unknown>, "isLoadingError" | "isRefetchError" | "dataUpdatedAt" | "errorUpdatedAt" | "failureCount" | "isFetchedAfterMount" | "isPaused" | "isPlaceholderData" | "isPreviousData" | "isStale" | "remove">;
+    status: "error" | "success" | "idle" | "loading";
+    internal: Pick<import("react-query").QueryObserverResult<unknown, unknown>, "dataUpdatedAt" | "errorUpdatedAt" | "failureCount" | "isFetchedAfterMount" | "isLoadingError" | "isPaused" | "isPlaceholderData" | "isPreviousData" | "isRefetchError" | "isStale" | "remove">;
 };

package/dist/declarations/src/hooks/ens/useEnsAddress.d.ts

@@ -11,8 +11,8 @@ export declare const queryKey: ({ chainId, name, }: {
     readonly name: string | undefined;
 }];
 export declare function useEnsAddress({ cacheTime, chainId: chainId_, enabled, name, staleTime, // 24 hours
-suspense, onError, onSettled, onSuccess, }?: UseEnsAddressArgs & UseEnsAddressConfig): Pick<import("react-query").QueryObserverResult<FetchEnsAddressResult, Error>, "data" | "error" | "isError" | "isLoading" | "isSuccess" | "isFetched" | "isFetching" | "isRefetching" | "refetch" | "fetchStatus"> & {
+suspense, onError, onSettled, onSuccess, }?: UseEnsAddressArgs & UseEnsAddressConfig): Pick<import("react-query").QueryObserverResult<FetchEnsAddressResult, Error>, "data" | "error" | "fetchStatus" | "isError" | "isFetched" | "isFetching" | "isLoading" | "isRefetching" | "isSuccess" | "refetch"> & {
     isIdle: boolean;
-    status: "error" | "loading" | "success" | "idle";
-    internal: Pick<import("react-query").QueryObserverResult<unknown, unknown>, "isLoadingError" | "isRefetchError" | "dataUpdatedAt" | "errorUpdatedAt" | "failureCount" | "isFetchedAfterMount" | "isPaused" | "isPlaceholderData" | "isPreviousData" | "isStale" | "remove">;
+    status: "error" | "success" | "idle" | "loading";
+    internal: Pick<import("react-query").QueryObserverResult<unknown, unknown>, "dataUpdatedAt" | "errorUpdatedAt" | "failureCount" | "isFetchedAfterMount" | "isLoadingError" | "isPaused" | "isPlaceholderData" | "isPreviousData" | "isRefetchError" | "isStale" | "remove">;
 };

package/dist/declarations/src/hooks/ens/useEnsAvatar.d.ts

@@ -11,8 +11,8 @@ export declare const queryKey: ({ addressOrName, chainId, }: {
     readonly chainId: number | undefined;
 }];
 export declare function useEnsAvatar({ addressOrName, cacheTime, chainId: chainId_, enabled, staleTime, // 24 hours
-suspense, onError, onSettled, onSuccess, }?: UseEnsAvatarArgs & UseEnsLookupConfig): Pick<import("react-query").QueryObserverResult<FetchEnsAvatarResult, Error>, "data" | "error" | "isError" | "isLoading" | "isSuccess" | "isFetched" | "isFetching" | "isRefetching" | "refetch" | "fetchStatus"> & {
+suspense, onError, onSettled, onSuccess, }?: UseEnsAvatarArgs & UseEnsLookupConfig): Pick<import("react-query").QueryObserverResult<FetchEnsAvatarResult, Error>, "data" | "error" | "fetchStatus" | "isError" | "isFetched" | "isFetching" | "isLoading" | "isRefetching" | "isSuccess" | "refetch"> & {
     isIdle: boolean;
-    status: "error" | "loading" | "success" | "idle";
-    internal: Pick<import("react-query").QueryObserverResult<unknown, unknown>, "isLoadingError" | "isRefetchError" | "dataUpdatedAt" | "errorUpdatedAt" | "failureCount" | "isFetchedAfterMount" | "isPaused" | "isPlaceholderData" | "isPreviousData" | "isStale" | "remove">;
+    status: "error" | "success" | "idle" | "loading";
+    internal: Pick<import("react-query").QueryObserverResult<unknown, unknown>, "dataUpdatedAt" | "errorUpdatedAt" | "failureCount" | "isFetchedAfterMount" | "isLoadingError" | "isPaused" | "isPlaceholderData" | "isPreviousData" | "isRefetchError" | "isStale" | "remove">;
 };

package/dist/declarations/src/hooks/ens/useEnsName.d.ts

@@ -11,8 +11,8 @@ export declare const queryKey: ({ address, chainId, }: {
     readonly chainId: number | undefined;
 }];
 export declare function useEnsName({ address, cacheTime, chainId: chainId_, enabled, staleTime, // 24 hours
-suspense, onError, onSettled, onSuccess, }?: UseEnsNameArgs & UseEnsNameConfig): Pick<import("react-query").QueryObserverResult<FetchEnsNameResult, Error>, "data" | "error" | "isError" | "isLoading" | "isSuccess" | "isFetched" | "isFetching" | "isRefetching" | "refetch" | "fetchStatus"> & {
+suspense, onError, onSettled, onSuccess, }?: UseEnsNameArgs & UseEnsNameConfig): Pick<import("react-query").QueryObserverResult<FetchEnsNameResult, Error>, "data" | "error" | "fetchStatus" | "isError" | "isFetched" | "isFetching" | "isLoading" | "isRefetching" | "isSuccess" | "refetch"> & {
     isIdle: boolean;
-    status: "error" | "loading" | "success" | "idle";
-    internal: Pick<import("react-query").QueryObserverResult<unknown, unknown>, "isLoadingError" | "isRefetchError" | "dataUpdatedAt" | "errorUpdatedAt" | "failureCount" | "isFetchedAfterMount" | "isPaused" | "isPlaceholderData" | "isPreviousData" | "isStale" | "remove">;
+    status: "error" | "success" | "idle" | "loading";
+    internal: Pick<import("react-query").QueryObserverResult<unknown, unknown>, "dataUpdatedAt" | "errorUpdatedAt" | "failureCount" | "isFetchedAfterMount" | "isLoadingError" | "isPaused" | "isPlaceholderData" | "isPreviousData" | "isRefetchError" | "isStale" | "remove">;
 };

package/dist/declarations/src/hooks/ens/useEnsResolver.d.ts

@@ -11,8 +11,8 @@ export declare const queryKey: ({ chainId, name, }: {
     readonly name: string | undefined;
 }];
 export declare function useEnsResolver({ cacheTime, chainId: chainId_, enabled, name, staleTime, // 24 hours
-suspense, onError, onSettled, onSuccess, }?: UseEnsResolverArgs & UseEnsResolverConfig): Pick<import("react-query").QueryObserverResult<FetchEnsResolverResult, Error>, "data" | "error" | "isError" | "isLoading" | "isSuccess" | "isFetched" | "isFetching" | "isRefetching" | "refetch" | "fetchStatus"> & {
+suspense, onError, onSettled, onSuccess, }?: UseEnsResolverArgs & UseEnsResolverConfig): Pick<import("react-query").QueryObserverResult<FetchEnsResolverResult, Error>, "data" | "error" | "fetchStatus" | "isError" | "isFetched" | "isFetching" | "isLoading" | "isRefetching" | "isSuccess" | "refetch"> & {
     isIdle: boolean;
-    status: "error" | "loading" | "success" | "idle";
-    internal: Pick<import("react-query").QueryObserverResult<unknown, unknown>, "isLoadingError" | "isRefetchError" | "dataUpdatedAt" | "errorUpdatedAt" | "failureCount" | "isFetchedAfterMount" | "isPaused" | "isPlaceholderData" | "isPreviousData" | "isStale" | "remove">;
+    status: "error" | "success" | "idle" | "loading";
+    internal: Pick<import("react-query").QueryObserverResult<unknown, unknown>, "dataUpdatedAt" | "errorUpdatedAt" | "failureCount" | "isFetchedAfterMount" | "isLoadingError" | "isPaused" | "isPlaceholderData" | "isPreviousData" | "isRefetchError" | "isStale" | "remove">;
 };

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

@@ -1,7 +1,7 @@
-export { useAccount, useBalance, useConnect, useDisconnect, useNetwork, useSigner, useSignMessage, useSignTypedData, } from './accounts';
-export { useContract, useContractEvent, useContractRead, useContractWrite, useToken, } from './contracts';
+export { useAccount, useBalance, useConnect, useDisconnect, useNetwork, useSigner, useSignMessage, useSignTypedData, useSwitchNetwork, } from './accounts';
+export { paginatedIndexesConfig, useContract, useContractEvent, useContractInfiniteReads, useContractRead, useContractReads, useContractWrite, useToken, } from './contracts';
 export { useEnsAddress, useEnsAvatar, useEnsName, useEnsResolver } from './ens';
 export { useBlockNumber, useFeeData } from './network-status';
 export { useProvider, useWebSocketProvider } from './providers';
 export { useSendTransaction, useWaitForTransaction } from './transactions';
-export { useChainId, useQuery } from './utils';
+export { useChainId, useBaseQuery, useQuery, useInfiniteQuery } from './utils';

package/dist/declarations/src/hooks/network-status/useBlockNumber.d.ts

@@ -11,9 +11,9 @@ export declare const queryKey: ({ chainId }: {
     readonly entity: "blockNumber";
     readonly chainId: number | undefined;
 }];
-export declare function useBlockNumber({ cacheTime, chainId: chainId_, enabled, staleTime, suspense, watch, onError, onSettled, onSuccess, }?: UseBlockNumberArgs & UseBlockNumberConfig): Pick<import("react-query").QueryObserverResult<number, Error>, "data" | "error" | "isError" | "isLoading" | "isSuccess" | "isFetched" | "isFetching" | "isRefetching" | "refetch" | "fetchStatus"> & {
+export declare function useBlockNumber({ cacheTime, chainId: chainId_, enabled, staleTime, suspense, watch, onError, onSettled, onSuccess, }?: UseBlockNumberArgs & UseBlockNumberConfig): Pick<import("react-query").QueryObserverResult<number, Error>, "data" | "error" | "fetchStatus" | "isError" | "isFetched" | "isFetching" | "isLoading" | "isRefetching" | "isSuccess" | "refetch"> & {
     isIdle: boolean;
-    status: "error" | "loading" | "success" | "idle";
-    internal: Pick<import("react-query").QueryObserverResult<unknown, unknown>, "isLoadingError" | "isRefetchError" | "dataUpdatedAt" | "errorUpdatedAt" | "failureCount" | "isFetchedAfterMount" | "isPaused" | "isPlaceholderData" | "isPreviousData" | "isStale" | "remove">;
+    status: "error" | "success" | "idle" | "loading";
+    internal: Pick<import("react-query").QueryObserverResult<unknown, unknown>, "dataUpdatedAt" | "errorUpdatedAt" | "failureCount" | "isFetchedAfterMount" | "isLoadingError" | "isPaused" | "isPlaceholderData" | "isPreviousData" | "isRefetchError" | "isStale" | "remove">;
 };
 export {};