wagmi 0.2.21 → 0.3.0-next.0

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

@@ -1,30 +1,88 @@
-import { Chain, SwitchChainError } from 'wagmi-core';
-export declare const useNetwork: () => readonly [{
-    readonly data: {
-        readonly chain: {
-            id: number;
-            unsupported: boolean | undefined;
-            name?: string | undefined;
-            nativeCurrency?: {
-                name: string;
-                symbol: string;
-                decimals: 18;
-            } | undefined;
-            rpcUrls?: string[] | undefined;
-            blockExplorers?: {
-                name: string;
-                url: string;
-            }[] | undefined;
-            testnet?: boolean | undefined;
-        } | undefined;
-        readonly chains: Chain[];
-    };
-    readonly error: Error | undefined;
-    readonly loading: boolean | undefined;
-}, ((chainId: number) => Promise<{
-    data: undefined;
-    error: SwitchChainError;
+import { SwitchNetworkResult } from '@wagmi/core';
+import { MutationConfig } from '../../types';
+export declare type UseConnectConfig = MutationConfig<SwitchNetworkResult, Error, number>;
+export declare const mutationKey = "switchNetwork";
+export declare const queryKey: () => readonly [{
+    readonly entity: "chain";
+}];
+export declare function useNetwork({ onError, onMutate, onSettled, onSuccess, }?: UseConnectConfig): {
+    readonly activeChain: (import("@wagmi/core").Chain & {
+        id: number;
+        unsupported?: boolean | undefined;
+    }) | undefined;
+    readonly chainId: number | undefined;
+    readonly chains: import("@wagmi/core").Chain[];
+    readonly switchNetwork: import("react-query").UseMutateFunction<import("@wagmi/core").Chain, Error, number, unknown> | undefined;
+    readonly switchNetworkAsync: import("react-query").UseMutateAsyncFunction<import("@wagmi/core").Chain, Error, number, unknown> | undefined;
+    readonly data: undefined;
+    readonly error: null;
+    readonly isError: false;
+    readonly isIdle: true;
+    readonly isLoading: false;
+    readonly isSuccess: false;
+    readonly status: "idle";
+    readonly reset: () => void;
+    readonly context: unknown;
+    readonly failureCount: number;
+    readonly isPaused: boolean;
 } | {
-    data: Chain | undefined;
-    error: undefined;
-}>) | undefined];
+    readonly activeChain: (import("@wagmi/core").Chain & {
+        id: number;
+        unsupported?: boolean | undefined;
+    }) | undefined;
+    readonly chainId: number | undefined;
+    readonly chains: import("@wagmi/core").Chain[];
+    readonly switchNetwork: import("react-query").UseMutateFunction<import("@wagmi/core").Chain, Error, number, unknown> | undefined;
+    readonly switchNetworkAsync: import("react-query").UseMutateAsyncFunction<import("@wagmi/core").Chain, Error, number, unknown> | undefined;
+    readonly data: undefined;
+    readonly error: null;
+    readonly isError: false;
+    readonly isIdle: false;
+    readonly isLoading: true;
+    readonly isSuccess: false;
+    readonly status: "loading";
+    readonly reset: () => void;
+    readonly context: unknown;
+    readonly failureCount: number;
+    readonly isPaused: boolean;
+} | {
+    readonly activeChain: (import("@wagmi/core").Chain & {
+        id: number;
+        unsupported?: boolean | undefined;
+    }) | undefined;
+    readonly chainId: number | undefined;
+    readonly chains: import("@wagmi/core").Chain[];
+    readonly switchNetwork: import("react-query").UseMutateFunction<import("@wagmi/core").Chain, Error, number, unknown> | undefined;
+    readonly switchNetworkAsync: import("react-query").UseMutateAsyncFunction<import("@wagmi/core").Chain, Error, number, unknown> | undefined;
+    readonly data: undefined;
+    readonly error: Error;
+    readonly isError: true;
+    readonly isIdle: false;
+    readonly isLoading: false;
+    readonly isSuccess: false;
+    readonly status: "error";
+    readonly reset: () => void;
+    readonly context: unknown;
+    readonly failureCount: number;
+    readonly isPaused: boolean;
+} | {
+    readonly activeChain: (import("@wagmi/core").Chain & {
+        id: number;
+        unsupported?: boolean | undefined;
+    }) | undefined;
+    readonly chainId: number | undefined;
+    readonly chains: import("@wagmi/core").Chain[];
+    readonly switchNetwork: import("react-query").UseMutateFunction<import("@wagmi/core").Chain, Error, number, unknown> | undefined;
+    readonly switchNetworkAsync: import("react-query").UseMutateAsyncFunction<import("@wagmi/core").Chain, Error, number, unknown> | undefined;
+    readonly data: import("@wagmi/core").Chain;
+    readonly error: null;
+    readonly isError: false;
+    readonly isIdle: false;
+    readonly isLoading: false;
+    readonly isSuccess: true;
+    readonly status: "success";
+    readonly reset: () => void;
+    readonly context: unknown;
+    readonly failureCount: number;
+    readonly isPaused: boolean;
+};

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

@@ -1,18 +1,66 @@
-import { Bytes } from 'ethers/lib/utils';
-export declare type Config = {
-    /** Message to sign with wallet */
-    message?: Bytes | string;
-};
-export declare const useSignMessage: ({ message }?: Config) => readonly [{
-    readonly data: string | undefined;
-    readonly error: Error | undefined;
-    readonly loading: boolean | undefined;
-}, (config?: {
-    message?: Config['message'];
-} | undefined) => Promise<{
-    data: string;
-    error: undefined;
+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 = "signMessage";
+export declare function useSignMessage({ message, onError, onMutate, onSettled, onSuccess, }?: UseSignMessageArgs & UseSignMessageConfig): {
+    signMessage: (args?: SignMessageArgs | undefined) => void;
+    signMessageAsync: (args?: SignMessageArgs | undefined) => Promise<string>;
+    data: undefined;
+    error: null;
+    isError: false;
+    isIdle: true;
+    isLoading: false;
+    isSuccess: false;
+    status: "idle";
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    isPaused: boolean;
+    variables: SignMessageArgs | undefined;
+} | {
+    signMessage: (args?: SignMessageArgs | undefined) => void;
+    signMessageAsync: (args?: SignMessageArgs | undefined) => Promise<string>;
+    data: undefined;
+    error: null;
+    isError: false;
+    isIdle: false;
+    isLoading: true;
+    isSuccess: false;
+    status: "loading";
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    isPaused: boolean;
+    variables: SignMessageArgs | undefined;
 } | {
+    signMessage: (args?: SignMessageArgs | undefined) => void;
+    signMessageAsync: (args?: SignMessageArgs | undefined) => Promise<string>;
     data: undefined;
     error: Error;
-}>];
+    isError: true;
+    isIdle: false;
+    isLoading: false;
+    isSuccess: false;
+    status: "error";
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    isPaused: boolean;
+    variables: SignMessageArgs | undefined;
+} | {
+    signMessage: (args?: SignMessageArgs | undefined) => void;
+    signMessageAsync: (args?: SignMessageArgs | undefined) => Promise<string>;
+    data: string;
+    error: null;
+    isError: false;
+    isIdle: false;
+    isLoading: false;
+    isSuccess: true;
+    status: "success";
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    isPaused: boolean;
+    variables: SignMessageArgs | undefined;
+};

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

@@ -1,12 +1,118 @@
-import { Signer } from 'ethers';
-declare type Config = {
-    /** Disables fetching */
-    skip?: boolean;
+import { FetchSignerResult } from '@wagmi/core';
+import { QueryConfig } from '../../types';
+export declare type UseSignerConfig = Omit<QueryConfig<FetchSignerResult, Error>, 'cacheTime' | 'staleTime' | 'enabled'>;
+export declare const queryKey: () => readonly [{
+    readonly entity: "signer";
+}];
+export declare const queryFn: () => Promise<FetchSignerResult>;
+export declare function useSigner({ onError, onSettled, onSuccess, }?: UseSignerConfig): {
+    isIdle: boolean;
+    isFetching: boolean;
+    isLoading: boolean;
+    status: string;
+    data: undefined;
+    error: null;
+    isError: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isPlaceholderData: boolean;
+    isPreviousData: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: <TPageData>(options?: (import("react-query").RefetchOptions & import("react-query").RefetchQueryFilters<TPageData>) | undefined) => Promise<import("react-query").QueryObserverResult<import("ethers").Signer, Error>>;
+    remove: () => void;
+} | {
+    isIdle: boolean;
+    isFetching: boolean;
+    isLoading: boolean;
+    status: string;
+    data: undefined;
+    error: Error;
+    isError: true;
+    isLoadingError: true;
+    isRefetchError: false;
+    isSuccess: false;
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isPlaceholderData: boolean;
+    isPreviousData: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: <TPageData>(options?: (import("react-query").RefetchOptions & import("react-query").RefetchQueryFilters<TPageData>) | undefined) => Promise<import("react-query").QueryObserverResult<import("ethers").Signer, Error>>;
+    remove: () => void;
+} | {
+    isIdle: boolean;
+    isFetching: boolean;
+    isLoading: boolean;
+    status: string;
+    data: undefined;
+    error: null;
+    isError: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isPlaceholderData: boolean;
+    isPreviousData: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: <TPageData>(options?: (import("react-query").RefetchOptions & import("react-query").RefetchQueryFilters<TPageData>) | undefined) => Promise<import("react-query").QueryObserverResult<import("ethers").Signer, Error>>;
+    remove: () => void;
+} | {
+    isIdle: boolean;
+    isFetching: boolean;
+    isLoading: boolean;
+    status: string;
+    data: import("ethers").Signer;
+    error: Error;
+    isError: true;
+    isLoadingError: false;
+    isRefetchError: true;
+    isSuccess: false;
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isPlaceholderData: boolean;
+    isPreviousData: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: <TPageData>(options?: (import("react-query").RefetchOptions & import("react-query").RefetchQueryFilters<TPageData>) | undefined) => Promise<import("react-query").QueryObserverResult<import("ethers").Signer, Error>>;
+    remove: () => void;
+} | {
+    isIdle: boolean;
+    isFetching: boolean;
+    isLoading: boolean;
+    status: string;
+    data: import("ethers").Signer;
+    error: null;
+    isError: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isPlaceholderData: boolean;
+    isPreviousData: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: <TPageData>(options?: (import("react-query").RefetchOptions & import("react-query").RefetchQueryFilters<TPageData>) | undefined) => Promise<import("react-query").QueryObserverResult<import("ethers").Signer, Error>>;
+    remove: () => void;
 };
-declare type State = {
-    data?: Signer;
-    error?: Error;
-    loading?: boolean;
-};
-export declare const useSigner: ({ skip }?: Config) => readonly [State, () => Promise<Signer | undefined>];
-export {};

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

@@ -1,5 +1,5 @@
 export { useContract } from './useContract';
 export { useContractEvent } from './useContractEvent';
 export { useContractRead } from './useContractRead';
-export { useContractWrite as useContractWrite } from './useContractWrite';
+export { useContractWrite } from './useContractWrite';
 export { useToken } from './useToken';

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

@@ -1,11 +1,3 @@
-import { ContractInterface, Signer } from 'ethers';
-import { Provider } from '@ethersproject/providers';
-export declare type Config = {
-    /** Contract address or ENS name */
-    addressOrName: string;
-    /** Contract interface or ABI */
-    contractInterface: ContractInterface;
-    /** Signer or provider to attach to contract */
-    signerOrProvider?: Signer | Provider;
-};
-export declare const useContract: <Contract_1 = any>({ addressOrName, contractInterface, signerOrProvider, }: Config) => Contract_1;
+import { GetContractArgs } from '@wagmi/core';
+export declare type UseContractConfig = GetContractArgs;
+export declare const useContract: <Contract = any>({ addressOrName, contractInterface, signerOrProvider, }: UseContractConfig) => Contract;

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

@@ -1,8 +1,7 @@
 import { ethers } from 'ethers';
-import { Config as UseContractConfig } from './useContract';
-declare type Config = {
+import { UseContractConfig } from './useContract';
+export declare type UseContractEventConfig = {
     /** 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], { once }?: Config) => void;
-export {};
+export declare const useContractEvent: <Contract extends ethers.Contract = ethers.Contract>(contractConfig: UseContractConfig, eventName: Parameters<Contract["on"]>[0], listener: Parameters<Contract["on"]>[1], { once }?: UseContractEventConfig) => void;

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

@@ -1,26 +1,21 @@
-import { CallOverrides, ethers } from 'ethers';
-import { Config as UseContractConfig } from './useContract';
-declare type Config = {
-    /** Arguments to pass contract method */
-    args?: any | any[];
-    overrides?: CallOverrides;
-    /** Disables fetching */
-    skip?: boolean;
+import { ReadContractArgs, ReadContractConfig, ReadContractResult } from '@wagmi/core';
+import { QueryConfig } from '../../types';
+declare type UseContractReadArgs = Partial<ReadContractConfig> & {
     /** Subscribe to changes */
     watch?: boolean;
 };
-export declare const useContractRead: <Contract extends ethers.Contract = ethers.Contract>(contractConfig: UseContractConfig, functionName: string, { args, overrides, skip, watch }?: Config) => readonly [{
-    readonly data: ethers.utils.Result | undefined;
-    readonly error: Error | undefined;
-    readonly loading: boolean | undefined;
-}, (config?: {
-    args?: Config['args'];
-    overrides?: Config['overrides'];
-} | undefined) => Promise<{
-    data: ethers.utils.Result;
-    error: undefined;
-} | {
-    data: undefined;
-    error: Error;
-}>];
+export declare type UseContractReadConfig = QueryConfig<ReadContractResult, Error>;
+export declare const queryKey: ([contractConfig, functionName, { args, overrides }, { blockNumber, chainId },]: [import("@wagmi/core").GetContractArgs, string, Partial<ReadContractConfig>, {
+    blockNumber?: number | undefined;
+    chainId?: number | undefined;
+}]) => readonly [{
+    readonly entity: "readContract";
+    readonly args: any;
+    readonly blockNumber: number | undefined;
+    readonly chainId: number | undefined;
+    readonly contractConfig: import("@wagmi/core").GetContractArgs;
+    readonly functionName: string;
+    readonly overrides: import("ethers").CallOverrides | undefined;
+}];
+export declare function useContractRead(contractConfig: ReadContractArgs, functionName: string, { args, overrides, watch, cacheTime, enabled: enabled_, keepPreviousData, select, staleTime, suspense, onError, onSettled, onSuccess, }?: UseContractReadArgs & UseContractReadConfig): import("react-query").UseQueryResult<import("ethers/lib/utils").Result, Error>;
 export {};

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

@@ -1,22 +1,72 @@
-import { CallOverrides, ethers } from 'ethers';
-import { Config as UseContractConfig } from './useContract';
-declare type Config = {
-    /** Arguments to pass contract method */
-    args?: any | any[];
-    overrides?: CallOverrides;
-};
-export declare const useContractWrite: <Contract extends ethers.Contract = ethers.Contract>(contractConfig: UseContractConfig, functionName: string, { args, overrides }?: Config) => readonly [{
-    readonly data: ethers.providers.TransactionResponse | undefined;
-    readonly error: Error | undefined;
-    readonly loading: boolean | undefined;
-}, (config?: {
-    args?: Config['args'];
-    overrides?: Config['overrides'];
-} | undefined) => Promise<{
-    data: ethers.providers.TransactionResponse;
-    error: undefined;
+import { WriteContractArgs, WriteContractConfig, WriteContractResult } from '@wagmi/core';
+import { MutationConfig } from '../../types';
+export declare type UseContractWriteArgs = Partial<WriteContractConfig>;
+export declare type UseContractWriteConfig = MutationConfig<WriteContractResult, Error, UseContractWriteArgs>;
+export declare const mutationKey: ([contractConfig, functionName, { args, overrides },]: [WriteContractArgs, string, Partial<WriteContractConfig>]) => readonly [{
+    readonly entity: "writeContract";
+    readonly args: any;
+    readonly contractConfig: import("@wagmi/core").GetContractArgs;
+    readonly functionName: string;
+    readonly overrides: import("ethers").CallOverrides | undefined;
+}];
+export declare function useContractWrite(contractConfig: WriteContractArgs, functionName: string, { args, overrides, onError, onMutate, onSettled, onSuccess, }?: UseContractWriteArgs & UseContractWriteConfig): {
+    write: (overrideConfig?: WriteContractConfig | undefined) => void;
+    writeAsync: (overrideConfig?: WriteContractConfig | undefined) => Promise<import("@ethersproject/abstract-provider").TransactionResponse>;
+    data: undefined;
+    error: null;
+    isError: false;
+    isIdle: true;
+    isLoading: false;
+    isSuccess: false;
+    status: "idle";
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    isPaused: boolean;
+    variables: Partial<WriteContractConfig> | undefined;
+} | {
+    write: (overrideConfig?: WriteContractConfig | undefined) => void;
+    writeAsync: (overrideConfig?: WriteContractConfig | undefined) => Promise<import("@ethersproject/abstract-provider").TransactionResponse>;
+    data: undefined;
+    error: null;
+    isError: false;
+    isIdle: false;
+    isLoading: true;
+    isSuccess: false;
+    status: "loading";
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    isPaused: boolean;
+    variables: Partial<WriteContractConfig> | undefined;
 } | {
+    write: (overrideConfig?: WriteContractConfig | undefined) => void;
+    writeAsync: (overrideConfig?: WriteContractConfig | undefined) => Promise<import("@ethersproject/abstract-provider").TransactionResponse>;
     data: undefined;
     error: Error;
-}>];
-export {};
+    isError: true;
+    isIdle: false;
+    isLoading: false;
+    isSuccess: false;
+    status: "error";
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    isPaused: boolean;
+    variables: Partial<WriteContractConfig> | undefined;
+} | {
+    write: (overrideConfig?: WriteContractConfig | undefined) => void;
+    writeAsync: (overrideConfig?: WriteContractConfig | undefined) => Promise<import("@ethersproject/abstract-provider").TransactionResponse>;
+    data: import("@ethersproject/abstract-provider").TransactionResponse;
+    error: null;
+    isError: false;
+    isIdle: false;
+    isLoading: false;
+    isSuccess: true;
+    status: "success";
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    isPaused: boolean;
+    variables: Partial<WriteContractConfig> | undefined;
+};

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

@@ -1,42 +1,13 @@
-import { BigNumber } from 'ethers';
-import { Unit } from 'wagmi-core';
-export declare type Config = {
-    address?: string;
-    formatUnits?: Unit | number;
-    skip?: boolean;
-};
-export declare const useToken: ({ address, formatUnits, skip, }?: Config) => readonly [{
-    readonly data: {
-        address: string | undefined;
-        decimals: number;
-        symbol: string;
-        totalSupply: {
-            formatted: string;
-            value: BigNumber;
-        };
-    } | undefined;
-    readonly error: Error | undefined;
-    readonly loading: boolean | undefined;
-}, (token: {
-    address: string;
-    decimals?: number | undefined;
-    image?: string | undefined;
-    symbol: string;
-}) => Promise<boolean | Error>, (config?: {
-    address: string;
-    formatUnits?: Config['formatUnits'];
-} | undefined) => Promise<{
-    data: {
-        address: string;
-        decimals: any;
-        symbol: any;
-        totalSupply: {
-            formatted: string;
-            value: any;
-        };
-    };
-    error: undefined;
-} | {
-    data: undefined;
-    error: Error;
-}>];
+import { FetchTokenArgs, FetchTokenResult } from '@wagmi/core';
+import { QueryConfig } from '../../types';
+export declare type UseTokenArgs = Partial<FetchTokenArgs>;
+export declare type UseTokenConfig = QueryConfig<FetchTokenResult, Error>;
+export declare const queryKey: ({ address, chainId, formatUnits, }: Partial<FetchTokenArgs> & {
+    chainId?: number | undefined;
+}) => readonly [{
+    readonly entity: "token";
+    readonly address: string | undefined;
+    readonly chainId: number | undefined;
+    readonly formatUnits: number | "wei" | "kwei" | "mwei" | "gwei" | "szabo" | "finney" | "ether" | undefined;
+}];
+export declare function useToken({ address, formatUnits, cacheTime, enabled, keepPreviousData, select, staleTime, suspense, onError, onSettled, onSuccess, }?: UseTokenArgs & UseTokenConfig): import("react-query").UseQueryResult<FetchTokenResult, Error>;

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

@@ -1,4 +1,4 @@
+export { useEnsAddress } from './useEnsAddress';
 export { useEnsAvatar } from './useEnsAvatar';
-export { useEnsLookup } from './useEnsLookup';
-export { useEnsResolveName } from './useEnsResolveName';
+export { useEnsName } from './useEnsName';
 export { useEnsResolver } from './useEnsResolver';

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

@@ -0,0 +1,17 @@
+import { FetchEnsAddressResult } from '@wagmi/core';
+import { QueryConfig } from '../../types';
+export declare type UseEnsAddressArgs = {
+    /** ENS name */
+    name?: string;
+};
+export declare type UseEnsAddressConfig = QueryConfig<FetchEnsAddressResult, Error>;
+export declare const queryKey: ({ chainId, name, }: {
+    chainId?: number | undefined;
+    name?: string | undefined;
+}) => readonly [{
+    readonly entity: "ensAddress";
+    readonly chainId: number | undefined;
+    readonly name: string | undefined;
+}];
+export declare function useEnsAddress({ name, cacheTime, enabled, keepPreviousData, select, staleTime, // 24 hours
+suspense, onError, onSettled, onSuccess, }?: UseEnsAddressArgs & UseEnsAddressConfig): import("react-query").UseQueryResult<FetchEnsAddressResult, Error>;

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

@@ -1,14 +1,17 @@
-declare type Config = {
+import { FetchEnsAvatarResult } from '@wagmi/core';
+import { QueryConfig } from '../../types';
+export declare type UseEnsAvatarArgs = {
     /** Address or ENS name */
-    addressOrName?: string | null;
-    /** Disables fetching */
-    skip?: boolean;
+    addressOrName?: string;
 };
-export declare const useEnsAvatar: ({ addressOrName, skip }?: Config) => readonly [{
-    readonly data: string | null | undefined;
-    readonly loading: boolean;
-    readonly error: Error | undefined;
-}, (config?: {
-    addressOrName: string;
-} | undefined) => Promise<string | Error | null>];
-export {};
+export declare type UseEnsLookupConfig = QueryConfig<FetchEnsAvatarResult, Error>;
+export declare const queryKey: ({ addressOrName, chainId, }: {
+    addressOrName?: UseEnsAvatarArgs['addressOrName'];
+    chainId?: number | undefined;
+}) => readonly [{
+    readonly entity: "ensAvatar";
+    readonly addressOrName: string | undefined;
+    readonly chainId: number | undefined;
+}];
+export declare function useEnsAvatar({ addressOrName, cacheTime, enabled, keepPreviousData, select, staleTime, // 24 hours
+suspense, onError, onSettled, onSuccess, }?: UseEnsAvatarArgs & UseEnsLookupConfig): import("react-query").UseQueryResult<FetchEnsAvatarResult, Error>;

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

@@ -0,0 +1,17 @@
+import { FetchEnsNameResult } from '@wagmi/core';
+import { QueryConfig } from '../../types';
+export declare type UseEnsNameArgs = {
+    /** Address */
+    address?: string;
+};
+export declare type UseEnsNameConfig = QueryConfig<FetchEnsNameResult, Error>;
+export declare const queryKey: ({ address, chainId, }: {
+    address?: string | undefined;
+    chainId?: number | undefined;
+}) => readonly [{
+    readonly entity: "ensName";
+    readonly address: string | undefined;
+    readonly chainId: number | undefined;
+}];
+export declare function useEnsName({ address, cacheTime, enabled, keepPreviousData, select, staleTime, // 24 hours
+suspense, onError, onSettled, onSuccess, }?: UseEnsNameArgs & UseEnsNameConfig): import("react-query").UseQueryResult<FetchEnsNameResult, Error>;