@wagmi/core 0.7.7 → 0.7.8

package/dist/index.d.ts

@@ -1,14 +1,14 @@
-import { P as Provider, W as WebSocketProvider, C as Chain, U as Unit, S as Signer, H as Hash, a as ChainProviderFn, b as ProviderWithFallbackConfig } from './index-bacc1c49.js';
-export { C as Chain, a as ChainProviderFn, E as Ethereum, F as FallbackProviderConfig, H as Hash, P as Provider, b as ProviderWithFallbackConfig, S as Signer, U as Unit, W as WebSocketProvider, c as alchemyRpcUrls, d as allChains, e as chain, f as chainId, g as defaultChains, h as defaultL2Chains, i as etherscanBlockExplorers, j as infuraRpcUrls, p as publicRpcUrls, u as units } from './index-bacc1c49.js';
+import { P as Provider, W as WebSocketProvider, C as Chain, U as Unit, S as Signer, H as Hash, a as ChainProviderFn, b as ProviderWithFallbackConfig } from './index-58cffc47.js';
+export { C as Chain, a as ChainProviderFn, E as Ethereum, F as FallbackProviderConfig, H as Hash, P as Provider, b as ProviderWithFallbackConfig, S as Signer, U as Unit, W as WebSocketProvider, c as alchemyRpcUrls, d as allChains, e as chain, f as chainId, g as defaultChains, h as defaultL2Chains, i as etherscanBlockExplorers, j as infuraRpcUrls, p as publicRpcUrls, u as units } from './index-58cffc47.js';
 import { Mutate, StoreApi } from 'zustand/vanilla';
-import { C as Connector, a as ConnectorData } from './base-5bd9b5ed.js';
-export { C as Connector, a as ConnectorData, b as ConnectorEvents } from './base-5bd9b5ed.js';
+import { C as Connector, a as ConnectorData } from './base-a32d0b91.js';
+export { C as Connector, a as ConnectorData, b as ConnectorEvents } from './base-a32d0b91.js';
 import * as abitype from 'abitype';
-import { Address, ResolvedConfig, TypedDataDomain, Narrow, TypedData, TypedDataToPrimitiveTypes, Abi, ExtractAbiFunction, ExtractAbiEventNames, AbiParametersToPrimitiveTypes, ExtractAbiEvent, AbiFunction, AbiParameterToPrimitiveType, AbiEvent, ExtractAbiFunctionNames } from 'abitype';
+import { Address, ResolvedConfig, TypedDataDomain, Narrow, TypedData, TypedDataToPrimitiveTypes, Abi, ExtractAbiFunction, ExtractAbiEventNames, AbiParametersToPrimitiveTypes, ExtractAbiEvent, AbiFunction, AbiParameter, AbiParameterToPrimitiveType, AbiEvent, ExtractAbiFunctionNames } from 'abitype';
 export { Address } from 'abitype';
 import { PopulatedTransaction, Signer as Signer$1, providers, Contract as Contract$1, ethers, ContractInterface } from 'ethers';
-import { O as Options$2, D as DefaultOptions, G as GetConfig$1, a as GetOverridesForAbiStateMutability, U as UnionToIntersection, C as CountOccurrences, A as AbiItemName, I as IsUnknown, E as Event, b as ContractsConfig, c as ContractsResult, d as GetReturnType, e as Or, f as IsNever, N as NotEqual } from './contracts-3c4d70a1.js';
-export { I as InjectedConnector, a as InjectedConnectorOptions } from './injected-6980e5c3.js';
+import { O as Options$2, D as DefaultOptions, G as GetConfig$1, a as GetOverridesForAbiStateMutability, U as UnionToIntersection, C as CountOccurrences, A as AbiItemName, I as IsUnknown, E as Event, b as ContractsConfig, c as ContractsResult, d as GetReturnType, e as Or, f as IsNever, N as NotEqual } from './contracts-3880ee54.js';
+export { I as InjectedConnector, a as InjectedConnectorOptions } from './injected-82510902.js';
 import 'eventemitter3';
 
 /**
@@ -772,8 +772,8 @@ declare const erc4626ABI: readonly [{
     readonly type: "function";
 }];
 
-declare type BaseStorage = Pick<Storage, 'getItem' | 'setItem' | 'removeItem'>;
-declare type ClientStorage = {
+type BaseStorage = Pick<Storage, 'getItem' | 'setItem' | 'removeItem'>;
+type ClientStorage = {
     getItem<T>(key: string, defaultState?: T | null): T | null;
     setItem<T>(key: string, value: T | null): void;
     removeItem(key: string): void;
@@ -786,7 +786,7 @@ declare function createStorage({ deserialize, key: prefix, serialize, storage, }
     storage: BaseStorage;
 }): ClientStorage;
 
-declare type ClientConfig<TProvider extends Provider = Provider, TWebSocketProvider extends WebSocketProvider = WebSocketProvider> = {
+type ClientConfig<TProvider extends Provider = Provider, TWebSocketProvider extends WebSocketProvider = WebSocketProvider> = {
     /** Enables reconnecting to last used connector on init */
     autoConnect?: boolean;
     /**
@@ -812,8 +812,8 @@ declare type ClientConfig<TProvider extends Provider = Provider, TWebSocketProvi
         chainId?: number;
     }) => TWebSocketProvider | undefined) | TWebSocketProvider;
 };
-declare type Data$1<TProvider extends Provider> = ConnectorData<TProvider>;
-declare type State<TProvider extends Provider = Provider, TWebSocketProvider extends WebSocketProvider = WebSocketProvider> = {
+type Data$1<TProvider extends Provider> = ConnectorData<TProvider>;
+type State<TProvider extends Provider = Provider, TWebSocketProvider extends WebSocketProvider = WebSocketProvider> = {
     chains?: Connector['chains'];
     connector?: Connector;
     connectors: Connector[];
@@ -872,14 +872,14 @@ declare class Client<TProvider extends Provider = Provider, TWebSocketProvider e
 }
 declare function createClient<TProvider extends Provider = Provider, TWebSocketProvider extends WebSocketProvider = WebSocketProvider>(config: ClientConfig<TProvider, TWebSocketProvider>): Client<TProvider, TWebSocketProvider>;
 
-declare type ConnectArgs = {
+type ConnectArgs = {
     /** Chain ID to connect to */
     chainId?: number;
     /** Connector to connect */
     connector: Connector;
 };
-declare type Data<TProvider extends Provider = Provider> = Required<ConnectorData<TProvider>>;
-declare type ConnectResult<TProvider extends Provider = Provider> = {
+type Data<TProvider extends Provider = Provider> = Required<ConnectorData<TProvider>>;
+type ConnectResult<TProvider extends Provider = Provider> = {
     account: Data<TProvider>['account'];
     chain: Data<TProvider>['chain'];
     connector: Client<TProvider>['connector'];
@@ -889,7 +889,7 @@ declare function connect<TProvider extends Provider = Provider>({ chainId, conne
 
 declare function disconnect(): Promise<void>;
 
-declare type FetchBalanceArgs = {
+type FetchBalanceArgs = {
     /** Address of balance to check */
     address: Address;
     /** Chain id to use for provider */
@@ -899,7 +899,7 @@ declare type FetchBalanceArgs = {
     /** ERC-20 address */
     token?: Address;
 };
-declare type FetchBalanceResult = {
+type FetchBalanceResult = {
     decimals: ResolvedConfig['IntType'];
     formatted: string;
     symbol: string;
@@ -907,14 +907,14 @@ declare type FetchBalanceResult = {
 };
 declare function fetchBalance({ address, chainId, formatUnits: unit, token, }: FetchBalanceArgs): Promise<FetchBalanceResult>;
 
-declare type FetchSignerArgs = {
+type FetchSignerArgs = {
     /** Chain ID to use for signer */
     chainId?: number;
 };
-declare type FetchSignerResult<TSigner extends Signer = Signer> = TSigner | null;
+type FetchSignerResult<TSigner extends Signer = Signer> = TSigner | null;
 declare function fetchSigner<TSigner extends Signer = Signer>({ chainId, }?: FetchSignerArgs): Promise<FetchSignerResult<TSigner>>;
 
-declare type GetAccountResult<TProvider extends Provider = Provider> = {
+type GetAccountResult<TProvider extends Provider = Provider> = {
     address: NonNullable<Data$1<TProvider>['account']>;
     connector: NonNullable<Client<TProvider>['connector']>;
     isConnected: true;
@@ -949,7 +949,7 @@ declare type GetAccountResult<TProvider extends Provider = Provider> = {
 };
 declare function getAccount<TProvider extends Provider>(): GetAccountResult<TProvider>;
 
-declare type GetNetworkResult = {
+type GetNetworkResult = {
     chain?: Chain & {
         unsupported?: boolean;
     };
@@ -957,14 +957,14 @@ declare type GetNetworkResult = {
 };
 declare function getNetwork(): GetNetworkResult;
 
-declare type SignMessageArgs = {
+type SignMessageArgs = {
     /** Message to sign with wallet */
     message: string | Uint8Array;
 };
-declare type SignMessageResult = ResolvedConfig['BytesType'];
+type SignMessageResult = ResolvedConfig['BytesType'];
 declare function signMessage(args: SignMessageArgs): Promise<SignMessageResult>;
 
-declare type SignTypedDataArgs<TTypedData = unknown> = {
+type SignTypedDataArgs<TTypedData = unknown> = {
     /** Domain or domain signature for origin or contract */
     domain: TypedDataDomain;
     /** Named list of all type definitions */
@@ -984,17 +984,17 @@ declare type SignTypedDataArgs<TTypedData = unknown> = {
     /** Data to sign */
     value: TValue;
 } : never : never : never);
-declare type SignTypedDataResult = string;
+type SignTypedDataResult = string;
 declare function signTypedData<TTypedData extends TypedData>({ domain, types, value, }: SignTypedDataArgs<TTypedData>): Promise<SignTypedDataResult>;
 
-declare type SwitchNetworkArgs = {
+type SwitchNetworkArgs = {
     chainId: number;
 };
-declare type SwitchNetworkResult = Chain;
+type SwitchNetworkResult = Chain;
 declare function switchNetwork({ chainId, }: SwitchNetworkArgs): Promise<SwitchNetworkResult>;
 
-declare type WatchAccountCallback<TProvider extends Provider = Provider> = (data: GetAccountResult<TProvider>) => void;
-declare type WatchAccountConfig = {
+type WatchAccountCallback<TProvider extends Provider = Provider> = (data: GetAccountResult<TProvider>) => void;
+type WatchAccountConfig = {
     selector?({ address, connector, status, }: {
         address?: string;
         connector?: Connector;
@@ -1003,8 +1003,8 @@ declare type WatchAccountConfig = {
 };
 declare function watchAccount<TProvider extends Provider>(callback: WatchAccountCallback<TProvider>, { selector }?: WatchAccountConfig): () => void;
 
-declare type WatchNetworkCallback = (data: GetNetworkResult) => void;
-declare type WatchNetworkConfig = {
+type WatchNetworkCallback = (data: GetNetworkResult) => void;
+type WatchNetworkConfig = {
     selector?({ chainId, chains }: {
         chainId?: number;
         chains?: Chain[];
@@ -1012,11 +1012,11 @@ declare type WatchNetworkConfig = {
 };
 declare function watchNetwork(callback: WatchNetworkCallback, { selector }?: WatchNetworkConfig): () => void;
 
-declare type WatchSignerArgs = FetchSignerArgs;
-declare type WatchSignerCallback<TSigner extends Signer = Signer> = (data: FetchSignerResult<TSigner>) => void;
+type WatchSignerArgs = FetchSignerArgs;
+type WatchSignerCallback<TSigner extends Signer = Signer> = (data: FetchSignerResult<TSigner>) => void;
 declare function watchSigner<TSigner extends Signer = Signer>({ chainId }: WatchSignerArgs, callback: WatchSignerCallback<TSigner>): () => void;
 
-declare type FetchTokenArgs = {
+type FetchTokenArgs = {
     /** Address of ERC-20 token */
     address: Address;
     /** Chain id to use for provider */
@@ -1024,7 +1024,7 @@ declare type FetchTokenArgs = {
     /** Units for formatting output */
     formatUnits?: Unit | number;
 };
-declare type FetchTokenResult = {
+type FetchTokenResult = {
     address: Address;
     decimals: ResolvedConfig['IntType'];
     name: string;
@@ -1036,7 +1036,7 @@ declare type FetchTokenResult = {
 };
 declare function fetchToken({ address, chainId, formatUnits: units, }: FetchTokenArgs): Promise<FetchTokenResult>;
 
-declare type PrepareWriteContractConfig<TAbi = Abi, TFunctionName = string, TSigner extends Signer = Signer, TOptions extends Options$2 = DefaultOptions> = GetConfig$1<{
+type PrepareWriteContractConfig<TAbi = Abi, TFunctionName = string, TSigner extends Signer = Signer, TOptions extends Options$2 = DefaultOptions> = GetConfig$1<{
     abi: TAbi;
     functionName: TFunctionName;
     /** Chain id to use for provider */
@@ -1052,7 +1052,7 @@ declare type PrepareWriteContractConfig<TAbi = Abi, TFunctionName = string, TSig
     /** Custom signer */
     signer?: TSigner | null;
 }, 'nonpayable' | 'payable', TOptions>;
-declare type PrepareWriteContractResult<TAbi = Abi, TFunctionName extends string = string> = {
+type PrepareWriteContractResult<TAbi = Abi, TFunctionName extends string = string> = {
     abi: TAbi extends Abi ? [ExtractAbiFunction<TAbi, TFunctionName>] : TAbi;
     address: string;
     chainId?: number;
@@ -1080,7 +1080,7 @@ declare type PrepareWriteContractResult<TAbi = Abi, TFunctionName extends string
  */
 declare function prepareWriteContract<TAbi extends Abi | readonly unknown[], TFunctionName extends string, TSigner extends Signer = Signer>({ abi, address, args, chainId, functionName, overrides, signer: signer_, }: PrepareWriteContractConfig<TAbi, TFunctionName, TSigner>): Promise<PrepareWriteContractResult<TAbi, TFunctionName>>;
 
-declare type GetContractArgs<TAbi extends Abi | readonly unknown[] = Abi> = {
+type GetContractArgs<TAbi extends Abi | readonly unknown[] = Abi> = {
     /** Contract address */
     address: string;
     /** Contract ABI */
@@ -1088,15 +1088,15 @@ declare type GetContractArgs<TAbi extends Abi | readonly unknown[] = Abi> = {
     /** Signer or provider to attach to contract */
     signerOrProvider?: Signer$1 | providers.Provider;
 };
-declare type GetContractResult<TAbi = unknown> = TAbi extends Abi ? Contract<TAbi> & Contract$1 : Contract$1;
+type GetContractResult<TAbi = unknown> = TAbi extends Abi ? Contract<TAbi> & Contract$1 : Contract$1;
 declare function getContract<TAbi extends Abi | readonly unknown[]>({ address, abi, signerOrProvider, }: GetContractArgs<TAbi>): GetContractResult<TAbi>;
-declare type PropertyKeys = 'address' | 'attach' | 'connect' | 'deployed' | 'interface' | 'resolvedAddress';
-declare type FunctionKeys = 'callStatic' | 'estimateGas' | 'functions' | 'populateTransaction';
-declare type EventKeys = 'emit' | 'filters' | 'listenerCount' | 'listeners' | 'off' | 'on' | 'once' | 'queryFilter' | 'removeAllListeners' | 'removeListener';
-declare type BaseContract<TContract extends Record<keyof Pick<Contract$1, PropertyKeys | FunctionKeys | EventKeys>, unknown>> = Omit<Contract$1, PropertyKeys | FunctionKeys | EventKeys> & TContract;
-declare type InterfaceKeys = 'events' | 'functions';
-declare type BaseInterface<Interface extends Record<keyof Pick<ethers.utils.Interface, InterfaceKeys>, unknown>> = Omit<ethers.utils.Interface, InterfaceKeys> & Interface;
-declare type Contract<TAbi extends Abi, _Functions = Functions<TAbi>> = _Functions & BaseContract<{
+type PropertyKeys = 'address' | 'attach' | 'connect' | 'deployed' | 'interface' | 'resolvedAddress';
+type FunctionKeys = 'callStatic' | 'estimateGas' | 'functions' | 'populateTransaction';
+type EventKeys = 'emit' | 'filters' | 'listenerCount' | 'listeners' | 'off' | 'on' | 'once' | 'queryFilter' | 'removeAllListeners' | 'removeListener';
+type BaseContract<TContract extends Record<keyof Pick<Contract$1, PropertyKeys | FunctionKeys | EventKeys>, unknown>> = Omit<Contract$1, PropertyKeys | FunctionKeys | EventKeys> & TContract;
+type InterfaceKeys = 'events' | 'functions';
+type BaseInterface<Interface extends Record<keyof Pick<ethers.utils.Interface, InterfaceKeys>, unknown>> = Omit<ethers.utils.Interface, InterfaceKeys> & Interface;
+type Contract<TAbi extends Abi, _Functions = Functions<TAbi>> = _Functions & BaseContract<{
     address: Address;
     resolvedAddress: Promise<Address>;
     attach(addressOrName: Address | string): Contract<TAbi>;
@@ -1133,7 +1133,7 @@ declare type Contract<TAbi extends Abi, _Functions = Functions<TAbi>> = _Functio
     removeAllListeners(eventFilter: ethers.EventFilter): Contract<TAbi>;
     removeListener: EventListener<TAbi>;
 }>;
-declare type Functions<TAbi extends Abi, Options extends {
+type Functions<TAbi extends Abi, Options extends {
     ReturnType?: any;
     ReturnTypeAsArray?: boolean;
 } = {
@@ -1150,7 +1150,7 @@ declare type Functions<TAbi extends Abi, Options extends {
         ]) => Promise<IsUnknown<Options['ReturnType']> extends true ? AbiFunctionReturnType<TAbiFunction> extends infer TAbiFunctionReturnType ? Options['ReturnTypeAsArray'] extends true ? [TAbiFunctionReturnType] : TAbiFunctionReturnType : never : Options['ReturnType']>;
     } : never;
 }[number]>;
-declare type AbiFunctionReturnType<TAbiFunction extends AbiFunction & {
+type AbiFunctionReturnType<TAbiFunction extends AbiFunction & {
     type: 'function';
 }> = ({
     payable: ethers.ContractTransaction;
@@ -1162,14 +1162,14 @@ declare type AbiFunctionReturnType<TAbiFunction extends AbiFunction & {
         } ? Output['name'] extends '' ? never : Output['name'] : never]: AbiParameterToPrimitiveType<Output>;
     } & AbiParametersToPrimitiveTypes<TAbiFunction['outputs']> : never;
 })[TAbiFunction['stateMutability']];
-declare type InterfaceFunctions<TAbi extends Abi> = UnionToIntersection<{
+type InterfaceFunctions<TAbi extends Abi> = UnionToIntersection<{
     [K in keyof TAbi]: TAbi[K] extends infer TAbiFunction extends AbiFunction & {
         type: 'function';
     } ? {
         [K in AbiItemName<TAbiFunction, true>]: ethers.utils.FunctionFragment;
     } : never;
 }[number]>;
-declare type InterfaceEvents<TAbi extends Abi> = UnionToIntersection<{
+type InterfaceEvents<TAbi extends Abi> = UnionToIntersection<{
     [K in keyof TAbi]: TAbi[K] extends infer TAbiEvent extends AbiEvent ? {
         [K in AbiItemName<TAbiEvent, true>]: ethers.utils.EventFragment;
     } : never;
@@ -1178,8 +1178,8 @@ interface EventListener<TAbi extends Abi> {
     <TEventName extends ExtractAbiEventNames<TAbi>>(eventName: TEventName, listener: Listener<TAbi, TEventName>): Contract<TAbi>;
     (eventFilter: ethers.EventFilter, listener: Listener<TAbi, ExtractAbiEventNames<TAbi>>): Contract<TAbi>;
 }
-declare type Listener<TAbi extends Abi, TEventName extends string, TAbiEvent extends AbiEvent = ExtractAbiEvent<TAbi, TEventName>> = AbiParametersToPrimitiveTypes<TAbiEvent['inputs']> extends infer TArgs extends readonly unknown[] ? (...args: [...args: TArgs, event: Event<TAbiEvent>]) => void : never;
-declare type Filters<TAbi extends Abi> = UnionToIntersection<{
+type Listener<TAbi extends Abi, TEventName extends string, TAbiEvent extends AbiEvent = ExtractAbiEvent<TAbi, TEventName>> = AbiParametersToPrimitiveTypes<TAbiEvent['inputs']> extends infer TArgs extends readonly unknown[] ? (...args: [...args: TArgs, event: Event<TAbiEvent>]) => void : never;
+type Filters<TAbi extends Abi> = UnionToIntersection<{
     [K in keyof TAbi]: TAbi[K] extends infer TAbiEvent extends AbiEvent ? {
         [K in CountOccurrences<TAbi, {
             name: TAbiEvent['name'];
@@ -1191,7 +1191,7 @@ declare type Filters<TAbi extends Abi> = UnionToIntersection<{
     } : never;
 }[number]>;
 
-declare type MulticallConfig<TContracts extends unknown[]> = {
+type MulticallConfig<TContracts extends unknown[]> = {
     /** Failures in the multicall will fail silently */
     allowFailure?: boolean;
     /** Chain id to use for provider */
@@ -1201,13 +1201,13 @@ declare type MulticallConfig<TContracts extends unknown[]> = {
     /** Call overrides */
     overrides?: GetOverridesForAbiStateMutability<'pure'> | GetOverridesForAbiStateMutability<'view'>;
 };
-declare type MulticallResult<TContracts extends unknown[]> = ContractsResult<TContracts>;
+type MulticallResult<TContracts extends unknown[]> = ContractsResult<TContracts>;
 declare function multicall<TAbi extends Abi | readonly unknown[], TFunctionName extends string, TContracts extends {
     abi: TAbi;
     functionName: TFunctionName;
 }[]>({ allowFailure, chainId, contracts, overrides, }: MulticallConfig<TContracts>): Promise<MulticallResult<TContracts>>;
 
-declare type ReadContractConfig<TAbi = Abi, TFunctionName = string, TOptions extends Options$2 = DefaultOptions> = GetConfig$1<{
+type ReadContractConfig<TAbi = Abi, TFunctionName = string, TOptions extends Options$2 = DefaultOptions> = GetConfig$1<{
     abi: TAbi;
     functionName: TFunctionName;
     /** Chain id to use for provider */
@@ -1215,16 +1215,16 @@ declare type ReadContractConfig<TAbi = Abi, TFunctionName = string, TOptions ext
     /** Call overrides */
     overrides?: GetOverridesForAbiStateMutability<'pure' | 'view'>;
 }, 'pure' | 'view', TOptions>;
-declare type ReadContractResult<TAbi = Abi, TFunctionName = string> = GetReturnType<{
+type ReadContractResult<TAbi = Abi, TFunctionName = string> = GetReturnType<{
     abi: TAbi;
     functionName: TFunctionName;
 }>;
 declare function readContract<TAbi extends Abi | readonly unknown[], TFunctionName extends string>({ address, args, chainId, abi, functionName, overrides, }: ReadContractConfig<TAbi, TFunctionName>): Promise<ReadContractResult<TAbi, TFunctionName>>;
 
-declare type Options$1 = Options$2 & {
+type Options$1 = Options$2 & {
     isContractsOptional?: boolean;
 };
-declare type ReadContractsConfig<TContracts extends unknown[], TOptions extends Options$1 = DefaultOptions, _Contracts = readonly [
+type ReadContractsConfig<TContracts extends unknown[], TOptions extends Options$1 = DefaultOptions, _Contracts = readonly [
     ...ContractsConfig<TContracts, {
         /** Chain id to use for provider */
         chainId?: number;
@@ -1241,13 +1241,13 @@ declare type ReadContractsConfig<TContracts extends unknown[], TOptions extends
     /** Contracts to query */
     contracts: _Contracts;
 });
-declare type ReadContractsResult<TContracts extends unknown[]> = ContractsResult<TContracts>;
+type ReadContractsResult<TContracts extends unknown[]> = ContractsResult<TContracts>;
 declare function readContracts<TAbi extends Abi | readonly unknown[], TFunctionName extends string, TContracts extends {
     abi: TAbi;
     functionName: TFunctionName;
 }[]>({ allowFailure, contracts, overrides, }: ReadContractsConfig<TContracts>): Promise<ReadContractsResult<TContracts>>;
 
-declare type ContractEventConfig<TAbi extends Abi | readonly unknown[] = Abi, TEventName extends string = string> = {
+type ContractEventConfig<TAbi extends Abi | readonly unknown[] = Abi, TEventName extends string = string> = {
     /** Contract address */
     address: string;
     /** Contract ABI */
@@ -1259,50 +1259,50 @@ declare type ContractEventConfig<TAbi extends Abi | readonly unknown[] = Abi, TE
     /** Receive only a single event */
     once?: boolean;
 };
-declare type GetConfig<T> = T extends {
+type GetConfig<T> = T extends {
     abi: infer TAbi extends Abi;
 } ? ContractEventConfig<TAbi, ExtractAbiEventNames<TAbi>> : T extends {
     abi: infer TAbi extends readonly unknown[];
     eventName: infer TEventName extends string;
 } ? ContractEventConfig<TAbi, TEventName> : ContractEventConfig;
-declare type WatchContractEventConfig<TAbi = Abi, TEventName = string> = GetConfig<{
+type WatchContractEventConfig<TAbi = Abi, TEventName = string> = GetConfig<{
     abi: TAbi;
     eventName: TEventName;
 }>;
-declare type WatchContractEventCallback<TAbi extends Abi | readonly unknown[] = Abi, TEventName extends string = string, TAbiEvent extends AbiEvent = TAbi extends Abi ? ExtractAbiEvent<TAbi, TEventName> : never> = AbiParametersToPrimitiveTypes<TAbiEvent['inputs']> extends infer TArgs extends readonly unknown[] ? Or<IsNever<TArgs>, NotEqual<TAbi, Abi>> extends true ? (...args: any) => void : (...args: [...args: TArgs, event: Event<TAbiEvent>]) => void : never;
+type WatchContractEventCallback<TAbi extends Abi | readonly unknown[] = Abi, TEventName extends string = string, TAbiEvent extends AbiEvent = TAbi extends Abi ? ExtractAbiEvent<TAbi, TEventName> : never> = AbiParametersToPrimitiveTypes<TAbiEvent['inputs']> extends infer TArgs extends readonly unknown[] ? Or<IsNever<TArgs>, NotEqual<TAbi, Abi>> extends true ? (...args: any) => void : (...args: [...args: TArgs, event: Event<TAbiEvent>]) => void : never;
 declare function watchContractEvent<TAbi extends Abi | readonly unknown[], TEventName extends string>({ address, abi, chainId, eventName, once, }: WatchContractEventConfig<TAbi, TEventName>, callback: WatchContractEventCallback<TAbi, TEventName>): () => void;
 
-declare type WatchMulticallConfig<TContracts extends unknown[]> = MulticallConfig<TContracts> & {
+type WatchMulticallConfig<TContracts extends unknown[]> = MulticallConfig<TContracts> & {
     listenToBlock?: boolean;
 };
-declare type WatchMulticallCallback<TContracts extends unknown[]> = (results: MulticallResult<TContracts>) => void;
+type WatchMulticallCallback<TContracts extends unknown[]> = (results: MulticallResult<TContracts>) => void;
 declare function watchMulticall<TAbi extends Abi | readonly unknown[], TFunctionName extends string, TContracts extends {
     abi: TAbi;
     functionName: TFunctionName;
 }[]>(config: WatchMulticallConfig<TContracts>, callback: WatchMulticallCallback<TContracts>): () => void;
 
-declare type WatchReadContractConfig<TAbi extends Abi | readonly unknown[] = Abi, TFunctionName extends string = string> = ReadContractConfig<TAbi, TFunctionName> & {
+type WatchReadContractConfig<TAbi extends Abi | readonly unknown[] = Abi, TFunctionName extends string = string> = ReadContractConfig<TAbi, TFunctionName> & {
     listenToBlock?: boolean;
 };
-declare type WatchReadContractCallback<TAbi extends Abi | readonly unknown[], TFunctionName extends string> = (result: ReadContractResult<TAbi, TFunctionName>) => void;
+type WatchReadContractCallback<TAbi extends Abi | readonly unknown[], TFunctionName extends string> = (result: ReadContractResult<TAbi, TFunctionName>) => void;
 declare function watchReadContract<TAbi extends Abi | readonly unknown[], TFunctionName extends TAbi extends Abi ? ExtractAbiFunctionNames<TAbi, 'view' | 'pure'> : string>(config: WatchReadContractConfig<TAbi, TFunctionName>, callback: WatchReadContractCallback<TAbi, TFunctionName>): () => void;
 
-declare type WatchReadContractsConfig<TContracts extends unknown[]> = ReadContractsConfig<TContracts> & {
+type WatchReadContractsConfig<TContracts extends unknown[]> = ReadContractsConfig<TContracts> & {
     listenToBlock?: boolean;
 };
-declare type WatchReadContractsCallback<TContracts extends unknown[]> = (results: ReadContractsResult<TContracts>) => void;
+type WatchReadContractsCallback<TContracts extends unknown[]> = (results: ReadContractsResult<TContracts>) => void;
 declare function watchReadContracts<TAbi extends Abi | readonly unknown[], TFunctionName extends string, TContracts extends {
     abi: TAbi;
     functionName: TFunctionName;
 }[]>(config: WatchReadContractsConfig<TContracts>, callback: WatchReadContractsCallback<TContracts>): () => void;
 
-declare type FetchTransactionArgs = {
+type FetchTransactionArgs = {
     /** Chain ID used to validate if the signer is connected to the target chain */
     chainId?: number;
     /** Transaction hash */
     hash: Hash;
 };
-declare type FetchTransactionResult = providers.TransactionResponse;
+type FetchTransactionResult = providers.TransactionResponse;
 /**
  * @description Fetches transaction for hash
  *
@@ -1316,7 +1316,7 @@ declare type FetchTransactionResult = providers.TransactionResponse;
  */
 declare function fetchTransaction({ chainId, hash, }: FetchTransactionArgs): Promise<FetchTransactionResult>;
 
-declare type PrepareSendTransactionArgs<TSigner extends Signer = Signer> = {
+type PrepareSendTransactionArgs<TSigner extends Signer = Signer> = {
     /** Chain ID used to validate if the signer is connected to the target chain */
     chainId?: number;
     /** Request data to prepare the transaction */
@@ -1325,7 +1325,7 @@ declare type PrepareSendTransactionArgs<TSigner extends Signer = Signer> = {
     };
     signer?: TSigner | null;
 };
-declare type PrepareSendTransactionResult = {
+type PrepareSendTransactionResult = {
     chainId?: number;
     request: providers.TransactionRequest & {
         to: Address;
@@ -1351,7 +1351,7 @@ declare type PrepareSendTransactionResult = {
  */
 declare function prepareSendTransaction({ chainId, request, signer: signer_, }: PrepareSendTransactionArgs): Promise<PrepareSendTransactionResult>;
 
-declare type SendTransactionPreparedRequest = {
+type SendTransactionPreparedRequest = {
     /**
      * `recklesslyUnprepared`: Allow to pass through an unprepared `request`. Note: This has
      * [UX pitfalls](/docs/prepare-hooks/intro#ux-pitfalls-without-prepare-hooks), it is highly recommended
@@ -1367,16 +1367,16 @@ declare type SendTransactionPreparedRequest = {
         gasLimit: NonNullable<providers.TransactionRequest['gasLimit']>;
     };
 };
-declare type SendTransactionUnpreparedRequest = {
+type SendTransactionUnpreparedRequest = {
     mode: 'recklesslyUnprepared';
     /** The unprepared request for sending a transaction. */
     request: providers.TransactionRequest;
 };
-declare type SendTransactionArgs = {
+type SendTransactionArgs = {
     /** Chain ID used to validate if the signer is connected to the target chain */
     chainId?: number;
 } & (SendTransactionPreparedRequest | SendTransactionUnpreparedRequest);
-declare type SendTransactionResult = {
+type SendTransactionResult = {
     hash: Hash;
     wait: providers.TransactionResponse['wait'];
 };
@@ -1384,7 +1384,7 @@ declare type SendTransactionResult = {
  * @description Function to send a transaction.
  *
  * It is recommended to pair this with the `prepareSendTransaction` function to avoid
- * [UX pitfalls](https://wagmi.sh/docs/prepare-hooks/intro#ux-pitfalls-without-prepare-hooks).
+ * [UX pitfalls](https://wagmi.sh/react/prepare-hooks/intro#ux-pitfalls-without-prepare-hooks).
  *
  * @example
  * import { prepareSendTransaction, sendTransaction } from '@wagmi/core'
@@ -1397,7 +1397,7 @@ declare type SendTransactionResult = {
  */
 declare function sendTransaction({ chainId, mode, request, }: SendTransactionArgs): Promise<SendTransactionResult>;
 
-declare type WaitForTransactionArgs = {
+type WaitForTransactionArgs = {
     /** Chain id to use for provider */
     chainId?: number;
     /**
@@ -1411,20 +1411,20 @@ declare type WaitForTransactionArgs = {
     /** Function resolving to transaction receipt */
     wait?: providers.TransactionResponse['wait'];
 };
-declare type WaitForTransactionResult = providers.TransactionReceipt;
+type WaitForTransactionResult = providers.TransactionReceipt;
 declare function waitForTransaction({ chainId, confirmations, hash, timeout, wait: wait_, }: WaitForTransactionArgs): Promise<WaitForTransactionResult>;
 
-declare type Options = Options$2 & {
+type Options = Options$2 & {
     isRequestOptional?: boolean;
 };
-declare type Request = PopulatedTransaction & {
+type Request = PopulatedTransaction & {
     to: Address;
     gasLimit: NonNullable<PopulatedTransaction['gasLimit']>;
 };
-declare type WriteContractPreparedArgs<TOptions extends Options = DefaultOptions> = {
+type WriteContractPreparedArgs<TOptions extends Options = DefaultOptions> = {
     /**
      * `recklesslyUnprepared`: Allow to pass through unprepared config. Note: This has
-     * [UX pitfalls](https://wagmi.sh/docs/prepare-hooks/intro#ux-pitfalls-without-prepare-hooks),
+     * [UX pitfalls](https://wagmi.sh/react/prepare-hooks/intro#ux-pitfalls-without-prepare-hooks),
      * it is highly recommended to not use this and instead prepare the request upfront
      * using the {@link prepareWriteContract} function.
      *
@@ -1441,7 +1441,7 @@ declare type WriteContractPreparedArgs<TOptions extends Options = DefaultOptions
     /** The prepared request. */
     request: Request;
 });
-declare type WriteContractUnpreparedArgs<TAbi = Abi, TFunctionName = string, TOptions extends Options = DefaultOptions> = {
+type WriteContractUnpreparedArgs<TAbi = Abi, TFunctionName = string, TOptions extends Options = DefaultOptions> = {
     mode: 'recklesslyUnprepared';
     request?: never;
 } & GetConfig$1<{
@@ -1456,18 +1456,18 @@ declare type WriteContractUnpreparedArgs<TAbi = Abi, TFunctionName = string, TOp
         infer TFunctionName_ extends string
     ] ? ExtractAbiFunction<TAbi_, TFunctionName_>['stateMutability'] : 'nonpayable' | 'payable'>;
 }, 'nonpayable' | 'payable', TOptions>;
-declare type WriteContractArgs<TAbi = Abi, TFunctionName = string, TOptions extends Options = DefaultOptions> = Omit<GetConfig$1<{
+type WriteContractArgs<TAbi = Abi, TFunctionName = string, TOptions extends Options = DefaultOptions> = Omit<GetConfig$1<{
     abi: TAbi;
     functionName: TFunctionName;
     /** Chain id to use for provider */
     chainId?: number;
 }, 'nonpayable' | 'payable', TOptions>, 'args'> & (WriteContractUnpreparedArgs<TAbi, TFunctionName, TOptions> | WriteContractPreparedArgs<TOptions>);
-declare type WriteContractResult = SendTransactionResult;
+type WriteContractResult = SendTransactionResult;
 /**
  * @description Function to call a contract write method.
  *
  * It is recommended to pair this with the {@link prepareWriteContract} function
- * to avoid [UX pitfalls](https://wagmi.sh/docs/prepare-hooks/intro#ux-pitfalls-without-prepare-hooks).
+ * to avoid [UX pitfalls](https://wagmi.sh/react/prepare-hooks/intro#ux-pitfalls-without-prepare-hooks).
  *
  * @example
  * import { prepareWriteContract, writeContract } from '@wagmi/core'
@@ -1481,55 +1481,55 @@ declare type WriteContractResult = SendTransactionResult;
  */
 declare function writeContract<TAbi extends Abi | readonly unknown[], TFunctionName extends string, TSigner extends Signer = Signer>({ address, args, chainId, abi, functionName, mode, overrides, request: request_, }: WriteContractArgs<TAbi, TFunctionName>): Promise<WriteContractResult>;
 
-declare type FetchEnsAddressArgs = {
+type FetchEnsAddressArgs = {
     /** Chain id to use for provider */
     chainId?: number;
     /** ENS name to resolve */
     name: string;
 };
-declare type FetchEnsAddressResult = Address | null;
+type FetchEnsAddressResult = Address | null;
 declare function fetchEnsAddress({ chainId, name, }: FetchEnsAddressArgs): Promise<FetchEnsAddressResult>;
 
-declare type FetchEnsAvatarArgs = {
+type FetchEnsAvatarArgs = {
     /** Address or ENS name */
     address: Address;
     /** Chain id to use for provider */
     chainId?: number;
 };
-declare type FetchEnsAvatarResult = string | null;
+type FetchEnsAvatarResult = string | null;
 declare function fetchEnsAvatar({ address, chainId, }: FetchEnsAvatarArgs): Promise<FetchEnsAvatarResult>;
 
-declare type FetchEnsNameArgs = {
+type FetchEnsNameArgs = {
     /** Address to lookup */
     address: Address;
     /** Chain id to use for provider */
     chainId?: number;
 };
-declare type FetchEnsNameResult = string | null;
+type FetchEnsNameResult = string | null;
 declare function fetchEnsName({ address, chainId, }: FetchEnsNameArgs): Promise<FetchEnsNameResult>;
 
-declare type FetchEnsResolverArgs = {
+type FetchEnsResolverArgs = {
     /** Chain id to use for provider */
     chainId?: number;
     /** ENS name to resolve */
     name: string;
 };
-declare type FetchEnsResolverResult = providers.Resolver | null;
+type FetchEnsResolverResult = providers.Resolver | null;
 declare function fetchEnsResolver({ chainId, name, }: FetchEnsResolverArgs): Promise<FetchEnsResolverResult>;
 
-declare type FetchBlockNumberArgs = {
+type FetchBlockNumberArgs = {
     chainId?: number;
 };
-declare type FetchBlockNumberResult = number;
+type FetchBlockNumberResult = number;
 declare function fetchBlockNumber({ chainId, }?: FetchBlockNumberArgs): Promise<FetchBlockNumberResult>;
 
-declare type FetchFeeDataArgs = {
+type FetchFeeDataArgs = {
     /** Units for formatting output */
     formatUnits?: Unit | number;
     /** Chain id to use for provider */
     chainId?: number;
 };
-declare type FetchFeeDataResult = providers.FeeData & {
+type FetchFeeDataResult = providers.FeeData & {
     formatted: {
         gasPrice: string | null;
         maxFeePerGas: string | null;
@@ -1538,31 +1538,31 @@ declare type FetchFeeDataResult = providers.FeeData & {
 };
 declare function fetchFeeData({ chainId, formatUnits: units, }?: FetchFeeDataArgs): Promise<FetchFeeDataResult>;
 
-declare type WatchBlockNumberArgs = {
+type WatchBlockNumberArgs = {
     chainId?: number;
     listen: boolean;
 };
-declare type WatchBlockNumberCallback = (blockNumber: FetchBlockNumberResult) => void;
+type WatchBlockNumberCallback = (blockNumber: FetchBlockNumberResult) => void;
 declare function watchBlockNumber(args: WatchBlockNumberArgs, callback: WatchBlockNumberCallback): () => void;
 
-declare type GetProviderArgs = {
+type GetProviderArgs = {
     /** Chain id to use for provider */
     chainId?: number;
 };
-declare type GetProviderResult<TProvider extends Provider = Provider> = TProvider;
+type GetProviderResult<TProvider extends Provider = Provider> = TProvider;
 declare function getProvider<TProvider extends Provider = Provider>({ chainId, }?: GetProviderArgs): GetProviderResult<TProvider>;
 
-declare type GetWebSocketProviderArgs = {
+type GetWebSocketProviderArgs = {
     /** Chain id to use for provider */
     chainId?: number;
 };
-declare type GetWebSocketProviderResult<TWebSocketProvider extends WebSocketProvider = WebSocketProvider> = TWebSocketProvider | undefined;
+type GetWebSocketProviderResult<TWebSocketProvider extends WebSocketProvider = WebSocketProvider> = TWebSocketProvider | undefined;
 declare function getWebSocketProvider<TWebSocketProvider extends WebSocketProvider = WebSocketProvider>({ chainId, }?: GetWebSocketProviderArgs): GetWebSocketProviderResult<TWebSocketProvider>;
 
-declare type WatchProviderCallback<TProvider extends Provider = Provider> = (provider: GetProviderResult<TProvider>) => void;
+type WatchProviderCallback<TProvider extends Provider = Provider> = (provider: GetProviderResult<TProvider>) => void;
 declare function watchProvider<TProvider extends Provider = Provider>(args: GetProviderArgs, callback: WatchProviderCallback<TProvider>): () => void;
 
-declare type WatchWebSocketProviderCallback<TWebSocketProvider extends WebSocketProvider = WebSocketProvider> = (webSocketProvider: GetWebSocketProviderResult<TWebSocketProvider>) => void;
+type WatchWebSocketProviderCallback<TWebSocketProvider extends WebSocketProvider = WebSocketProvider> = (webSocketProvider: GetWebSocketProviderResult<TWebSocketProvider>) => void;
 declare function watchWebSocketProvider<TWebSocketProvider extends WebSocketProvider = WebSocketProvider>(args: GetWebSocketProviderArgs, callback: WatchWebSocketProviderCallback<TWebSocketProvider>): () => void;
 
 /**
@@ -1698,7 +1698,7 @@ declare class UserRejectedRequestError extends ProviderRpcError {
     constructor(error: unknown);
 }
 
-declare type ConfigureChainsConfig = {
+type ConfigureChainsConfig = {
     pollingInterval?: number;
     stallTimeout?: number;
 } & ({
@@ -1741,8 +1741,8 @@ declare function parseContractResult({ abi, data, functionName, }: {
     functionName: string;
 }): any;
 
-declare type StandardReplacer = (key: string, value: any) => any;
-declare type CircularReplacer = (key: string, value: any, referenceKey: string) => any;
+type StandardReplacer = (key: string, value: any) => any;
+type CircularReplacer = (key: string, value: any, referenceKey: string) => any;
 /**
  * @function stringify
  *