@wagmi/core 0.7.6 → 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,19 +772,21 @@ 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;
 };
 declare const noopStorage: BaseStorage;
-declare function createStorage({ storage, key: prefix, }: {
-    storage: BaseStorage;
+declare function createStorage({ deserialize, key: prefix, serialize, storage, }: {
+    deserialize?: <T>(value: string) => T;
     key?: string;
+    serialize?: <T>(value: T) => string;
+    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;
     /**
@@ -810,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[];
@@ -870,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'];
@@ -887,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 */
@@ -897,7 +899,7 @@ declare type FetchBalanceArgs = {
     /** ERC-20 address */
     token?: Address;
 };
-declare type FetchBalanceResult = {
+type FetchBalanceResult = {
     decimals: ResolvedConfig['IntType'];
     formatted: string;
     symbol: string;
@@ -905,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;
@@ -947,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;
     };
@@ -955,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 */
@@ -982,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;
@@ -1001,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[];
@@ -1010,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 */
@@ -1022,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;
@@ -1034,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 */
@@ -1050,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;
@@ -1078,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 */
@@ -1086,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>;
@@ -1131,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;
 } = {
@@ -1148,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;
@@ -1160,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;
@@ -1176,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'];
@@ -1189,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 */
@@ -1199,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 */
@@ -1213,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;
@@ -1239,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 */
@@ -1257,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
  *
@@ -1314,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 */
@@ -1323,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;
@@ -1349,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
@@ -1365,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'];
 };
@@ -1382,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'
@@ -1395,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;
     /**
@@ -1409,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.
      *
@@ -1439,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<{
@@ -1454,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'
@@ -1479,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;
@@ -1536,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;
 
 /**
@@ -1696,7 +1698,7 @@ declare class UserRejectedRequestError extends ProviderRpcError {
     constructor(error: unknown);
 }
 
-declare type ConfigureChainsConfig = {
+type ConfigureChainsConfig = {
     pollingInterval?: number;
     stallTimeout?: number;
 } & ({
@@ -1724,6 +1726,8 @@ declare function configureChains<TProvider extends Provider = Provider, TWebSock
 /** Forked from https://github.com/epoberezkin/fast-deep-equal */
 declare function deepEqual(a: any, b: any): boolean;
 
+declare function deserialize(cachedString: string): any;
+
 declare function minimizeContractInterface<TAbi extends Abi | readonly unknown[]>(config: {
     abi: TAbi;
     functionName: TAbi extends Abi ? ExtractAbiFunctionNames<TAbi> : string;
@@ -1737,4 +1741,21 @@ declare function parseContractResult({ abi, data, functionName, }: {
     functionName: string;
 }): any;
 
-export { AddChainError, ChainDoesNotSupportMulticallError, ChainMismatchError, ChainNotConfiguredError, Client, ClientConfig, ConfigureChainsConfig, ConnectArgs, ConnectResult, ConnectorAlreadyConnectedError, ConnectorNotFoundError, ContractMethodDoesNotExistError, ContractMethodNoResultError, ContractMethodRevertedError, ContractResultDecodeError, FetchBalanceArgs, FetchBalanceResult, FetchBlockNumberArgs, FetchBlockNumberResult, FetchEnsAddressArgs, FetchEnsAddressResult, FetchEnsAvatarArgs, FetchEnsAvatarResult, FetchEnsNameArgs, FetchEnsNameResult, FetchEnsResolverArgs, FetchEnsResolverResult, FetchFeeDataArgs, FetchFeeDataResult, FetchSignerArgs, FetchSignerResult, FetchTokenArgs, FetchTokenResult, FetchTransactionArgs, FetchTransactionResult, GetAccountResult, GetContractArgs, GetContractResult, GetNetworkResult, GetProviderArgs, GetProviderResult, GetWebSocketProviderArgs, GetWebSocketProviderResult, MulticallConfig, MulticallResult, PrepareSendTransactionArgs, PrepareSendTransactionResult, PrepareWriteContractConfig, PrepareWriteContractResult, ProviderChainsNotFound, ProviderRpcError, ReadContractConfig, ReadContractResult, ReadContractsConfig, ReadContractsResult, ResourceUnavailableError, RpcError, SendTransactionArgs, SendTransactionPreparedRequest, SendTransactionResult, SendTransactionUnpreparedRequest, SignMessageArgs, SignMessageResult, SignTypedDataArgs, SignTypedDataResult, ClientStorage as Storage, SwitchChainError, SwitchChainNotSupportedError, SwitchNetworkArgs, SwitchNetworkResult, UserRejectedRequestError, WaitForTransactionArgs, WaitForTransactionResult, WatchAccountCallback, WatchBlockNumberArgs, WatchBlockNumberCallback, WatchMulticallCallback, WatchMulticallConfig, WatchNetworkCallback, WatchProviderCallback, WatchReadContractCallback, WatchReadContractConfig, WatchReadContractsCallback, WatchReadContractsConfig, WatchSignerCallback, WatchWebSocketProviderCallback, WriteContractArgs, WriteContractPreparedArgs, WriteContractResult, WriteContractUnpreparedArgs, configureChains, connect, createClient, createStorage, deepEqual, disconnect, erc20ABI, erc4626ABI, erc721ABI, fetchBalance, fetchBlockNumber, fetchEnsAddress, fetchEnsAvatar, fetchEnsName, fetchEnsResolver, fetchFeeData, fetchSigner, fetchToken, fetchTransaction, getAccount, getContract, getNetwork, getProvider, getWebSocketProvider, minimizeContractInterface, multicall, noopStorage, normalizeChainId, parseContractResult, prepareSendTransaction, prepareWriteContract, readContract, readContracts, sendTransaction, signMessage, signTypedData, switchNetwork, waitForTransaction, watchAccount, watchBlockNumber, watchContractEvent, watchMulticall, watchNetwork, watchProvider, watchReadContract, watchReadContracts, watchSigner, watchWebSocketProvider, writeContract };
+type StandardReplacer = (key: string, value: any) => any;
+type CircularReplacer = (key: string, value: any, referenceKey: string) => any;
+/**
+ * @function stringify
+ *
+ * @description
+ * stringifier that handles circular values
+ * Forked from https://github.com/planttheidea/fast-stringify
+ *
+ * @param value to stringify
+ * @param [replacer] a custom replacer function for handling standard values
+ * @param [indent] the number of spaces to indent the output by
+ * @param [circularReplacer] a custom replacer function for handling circular values
+ * @returns the stringified output
+ */
+declare function serialize(value: any, replacer?: StandardReplacer | null | undefined, indent?: number | null | undefined, circularReplacer?: CircularReplacer | null | undefined): string;
+
+export { AddChainError, ChainDoesNotSupportMulticallError, ChainMismatchError, ChainNotConfiguredError, Client, ClientConfig, ConfigureChainsConfig, ConnectArgs, ConnectResult, ConnectorAlreadyConnectedError, ConnectorNotFoundError, ContractMethodDoesNotExistError, ContractMethodNoResultError, ContractMethodRevertedError, ContractResultDecodeError, FetchBalanceArgs, FetchBalanceResult, FetchBlockNumberArgs, FetchBlockNumberResult, FetchEnsAddressArgs, FetchEnsAddressResult, FetchEnsAvatarArgs, FetchEnsAvatarResult, FetchEnsNameArgs, FetchEnsNameResult, FetchEnsResolverArgs, FetchEnsResolverResult, FetchFeeDataArgs, FetchFeeDataResult, FetchSignerArgs, FetchSignerResult, FetchTokenArgs, FetchTokenResult, FetchTransactionArgs, FetchTransactionResult, GetAccountResult, GetContractArgs, GetContractResult, GetNetworkResult, GetProviderArgs, GetProviderResult, GetWebSocketProviderArgs, GetWebSocketProviderResult, MulticallConfig, MulticallResult, PrepareSendTransactionArgs, PrepareSendTransactionResult, PrepareWriteContractConfig, PrepareWriteContractResult, ProviderChainsNotFound, ProviderRpcError, ReadContractConfig, ReadContractResult, ReadContractsConfig, ReadContractsResult, ResourceUnavailableError, RpcError, SendTransactionArgs, SendTransactionPreparedRequest, SendTransactionResult, SendTransactionUnpreparedRequest, SignMessageArgs, SignMessageResult, SignTypedDataArgs, SignTypedDataResult, ClientStorage as Storage, SwitchChainError, SwitchChainNotSupportedError, SwitchNetworkArgs, SwitchNetworkResult, UserRejectedRequestError, WaitForTransactionArgs, WaitForTransactionResult, WatchAccountCallback, WatchBlockNumberArgs, WatchBlockNumberCallback, WatchMulticallCallback, WatchMulticallConfig, WatchNetworkCallback, WatchProviderCallback, WatchReadContractCallback, WatchReadContractConfig, WatchReadContractsCallback, WatchReadContractsConfig, WatchSignerCallback, WatchWebSocketProviderCallback, WriteContractArgs, WriteContractPreparedArgs, WriteContractResult, WriteContractUnpreparedArgs, configureChains, connect, createClient, createStorage, deepEqual, deserialize, disconnect, erc20ABI, erc4626ABI, erc721ABI, fetchBalance, fetchBlockNumber, fetchEnsAddress, fetchEnsAvatar, fetchEnsName, fetchEnsResolver, fetchFeeData, fetchSigner, fetchToken, fetchTransaction, getAccount, getContract, getNetwork, getProvider, getWebSocketProvider, minimizeContractInterface, multicall, noopStorage, normalizeChainId, parseContractResult, prepareSendTransaction, prepareWriteContract, readContract, readContracts, sendTransaction, serialize, signMessage, signTypedData, switchNetwork, waitForTransaction, watchAccount, watchBlockNumber, watchContractEvent, watchMulticall, watchNetwork, watchProvider, watchReadContract, watchReadContracts, watchSigner, watchWebSocketProvider, writeContract };