@wagmi/core 0.6.12 → 0.7.0

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

@@ -1,23 +0,0 @@
-import { Narrow, TypedData, TypedDataDomain, TypedDataToPrimitiveTypes } from 'abitype';
-export declare type SignTypedDataArgs<TTypedData = unknown> = {
-    /** Domain or domain signature for origin or contract */
-    domain: TypedDataDomain;
-    /** Named list of all type definitions */
-    types: Narrow<TTypedData>;
-} & (TTypedData extends TypedData ? TypedDataToPrimitiveTypes<TTypedData> extends infer TSchema ? TSchema[keyof TSchema] extends infer TValue ? {
-    [key: string]: any;
-} extends TValue ? {
-    /**
-     * Data to sign
-     *
-     * Use a [const assertion](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-4.html#const-assertions) on {@link types} for type inference.
-     */
-    value: {
-        [key: string]: unknown;
-    };
-} : {
-    /** Data to sign */
-    value: TValue;
-} : never : never : never);
-export declare type SignTypedDataResult = string;
-export declare function signTypedData<TTypedData extends TypedData>({ domain, types, value, }: SignTypedDataArgs<TTypedData>): Promise<SignTypedDataResult>;

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

@@ -1,6 +0,0 @@
-import { Chain } from '../../types';
-export declare type SwitchNetworkArgs = {
-    chainId: number;
-};
-export declare type SwitchNetworkResult = Chain;
-export declare function switchNetwork({ chainId, }: SwitchNetworkArgs): Promise<SwitchNetworkResult>;

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

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

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

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

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

@@ -1,5 +0,0 @@
-import { Signer } from '../../types';
-import { FetchSignerArgs, FetchSignerResult } from './fetchSigner';
-export declare type WatchSignerArgs = FetchSignerArgs;
-export declare type WatchSignerCallback<TSigner extends Signer = Signer> = (data: FetchSignerResult<TSigner>) => void;
-export declare function watchSigner<TSigner extends Signer = Signer>({ chainId }: WatchSignerArgs, callback: WatchSignerCallback<TSigner>): () => void;

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

@@ -1,21 +0,0 @@
-import { Address, ResolvedConfig } from 'abitype';
-import { Unit } from '../../types';
-export declare type FetchTokenArgs = {
-    /** Address of ERC-20 token */
-    address: Address;
-    /** Chain id to use for provider */
-    chainId?: number;
-    /** Units for formatting output */
-    formatUnits?: Unit | number;
-};
-export declare type FetchTokenResult = {
-    address: Address;
-    decimals: ResolvedConfig['IntType'];
-    name: string;
-    symbol: string;
-    totalSupply: {
-        formatted: string;
-        value: ResolvedConfig['BigIntType'];
-    };
-};
-export declare function fetchToken({ address, chainId, formatUnits: units, }: FetchTokenArgs): Promise<FetchTokenResult>;

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

@@ -1,113 +0,0 @@
-import { Abi, AbiEvent, AbiFunction, AbiParameter, AbiParameterToPrimitiveType, AbiParametersToPrimitiveTypes, Address, ExtractAbiEvent, ExtractAbiEventNames, Narrow, ResolvedConfig } from 'abitype';
-import { Contract as EthersContract, Signer, ethers, providers } from 'ethers';
-import { AbiItemName, Event, GetOverridesForAbiStateMutability } from '../../types/contracts';
-import { CountOccurrences, IsUnknown, UnionToIntersection } from '../../types/utils';
-export declare type GetContractArgs<TAbi extends Abi | readonly unknown[] = Abi> = {
-    /** Contract address */
-    address: string;
-    /** Contract ABI */
-    abi: Narrow<TAbi>;
-    /** Signer or provider to attach to contract */
-    signerOrProvider?: Signer | providers.Provider;
-};
-export declare type GetContractResult<TAbi = unknown> = TAbi extends Abi ? Contract<TAbi> & EthersContract : EthersContract;
-export 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<EthersContract, PropertyKeys | FunctionKeys | EventKeys>, unknown>> = Omit<EthersContract, 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;
-export declare type Contract<TAbi extends Abi, _Functions = Functions<TAbi>> = _Functions & BaseContract<{
-    address: Address;
-    resolvedAddress: Promise<Address>;
-    attach(addressOrName: Address | string): Contract<TAbi>;
-    connect(signerOrProvider: ethers.Signer | ethers.providers.Provider | string): Contract<TAbi>;
-    deployed(): Promise<Contract<TAbi>>;
-    interface: BaseInterface<{
-        events: InterfaceEvents<TAbi>;
-        functions: InterfaceFunctions<TAbi>;
-    }>;
-    callStatic: _Functions;
-    estimateGas: Functions<TAbi, {
-        ReturnType: ResolvedConfig['BigIntType'];
-    }>;
-    functions: Functions<TAbi, {
-        ReturnTypeAsArray: true;
-    }>;
-    populateTransaction: Functions<TAbi, {
-        ReturnType: ethers.PopulatedTransaction;
-    }>;
-    emit<TEventName extends ExtractAbiEventNames<TAbi> | ethers.EventFilter>(eventName: TEventName, ...args: AbiParametersToPrimitiveTypes<ExtractAbiEvent<TAbi, TEventName extends string ? TEventName : ExtractAbiEventNames<TAbi>>['inputs']> extends infer TArgs extends readonly unknown[] ? TArgs : never): boolean;
-    filters: Filters<TAbi>;
-    listenerCount(): number;
-    listenerCount<TEventName extends ExtractAbiEventNames<TAbi>>(eventName: TEventName): number;
-    listenerCount(eventFilter: ethers.EventFilter): number;
-    listeners(): Array<(...args: any[]) => void>;
-    listeners<TEventName extends ExtractAbiEventNames<TAbi>>(eventName: TEventName): Array<Listener<TAbi, TEventName>>;
-    listeners(eventFilter: ethers.EventFilter): Array<Listener<TAbi, ExtractAbiEventNames<TAbi>>>;
-    off: EventListener<TAbi>;
-    on: EventListener<TAbi>;
-    once: EventListener<TAbi>;
-    queryFilter<TEventName extends ExtractAbiEventNames<TAbi>>(event: TEventName, fromBlockOrBlockhash?: string | number, toBlock?: string | number): Promise<Array<ethers.Event>>;
-    queryFilter(eventFilter: ethers.EventFilter, fromBlockOrBlockhash?: string | number, toBlock?: string | number): Promise<Array<ethers.Event>>;
-    removeAllListeners(eventName?: ExtractAbiEventNames<TAbi>): Contract<TAbi>;
-    removeAllListeners(eventFilter: ethers.EventFilter): Contract<TAbi>;
-    removeListener: EventListener<TAbi>;
-}>;
-declare type Functions<TAbi extends Abi, Options extends {
-    ReturnType?: any;
-    ReturnTypeAsArray?: boolean;
-} = {
-    ReturnTypeAsArray: false;
-}> = UnionToIntersection<{
-    [K in keyof TAbi]: TAbi[K] extends infer TAbiFunction extends AbiFunction & {
-        type: 'function';
-    } ? {
-        [K in CountOccurrences<TAbi, {
-            name: TAbiFunction['name'];
-        }> extends 1 ? AbiItemName<TAbiFunction> : AbiItemName<TAbiFunction, true>]: (...args: [
-            ...args: TAbiFunction['inputs'] extends infer TInputs extends readonly AbiParameter[] ? AbiParametersToPrimitiveTypes<TInputs> : never,
-            overrides?: GetOverridesForAbiStateMutability<TAbiFunction['stateMutability']>
-        ]) => 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: 'function';
-}> = ({
-    payable: ethers.ContractTransaction;
-    nonpayable: ethers.ContractTransaction;
-} & {
-    [_ in 'pure' | 'view']: TAbiFunction['outputs']['length'] extends infer TLength ? TLength extends 0 ? void : TLength extends 1 ? AbiParameterToPrimitiveType<TAbiFunction['outputs'][0]> : {
-        [Output in TAbiFunction['outputs'][number] as Output['name'] extends '' ? never : Output['name']]: AbiParameterToPrimitiveType<Output>;
-    } & AbiParametersToPrimitiveTypes<TAbiFunction['outputs']> : never;
-})[TAbiFunction['stateMutability']];
-declare 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<{
-    [K in keyof TAbi]: TAbi[K] extends infer TAbiEvent extends AbiEvent ? {
-        [K in AbiItemName<TAbiEvent, true>]: ethers.utils.EventFragment;
-    } : never;
-}[number]>;
-export 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<{
-    [K in keyof TAbi]: TAbi[K] extends infer TAbiEvent extends AbiEvent ? {
-        [K in CountOccurrences<TAbi, {
-            name: TAbiEvent['name'];
-        }> extends 1 ? AbiItemName<TAbiEvent> : AbiItemName<TAbiEvent, true>]: (...args: TAbiEvent['inputs'] extends infer TAbiParameters extends readonly (AbiParameter & {
-            indexed?: boolean;
-        })[] ? {
-            [K in keyof TAbiParameters]: TAbiParameters[K]['indexed'] extends true ? AbiParameterToPrimitiveType<TAbiParameters[K]> | null : null;
-        } : never) => ethers.EventFilter;
-    } : never;
-}[number]>;
-export {};

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

@@ -1,11 +0,0 @@
-export { fetchToken, type FetchTokenArgs, type FetchTokenResult, } from './fetchToken';
-export { prepareWriteContract, type PrepareWriteContractConfig, type PrepareWriteContractResult, } from './prepareWriteContract';
-export { getContract, type GetContractArgs, type GetContractResult, } from './getContract';
-export { multicall, type MulticallConfig, type MulticallResult, } from './multicall';
-export { readContract, type ReadContractConfig, type ReadContractResult, } from './readContract';
-export { readContracts, type ReadContractsConfig, type ReadContractsResult, } from './readContracts';
-export { watchContractEvent } from './watchContractEvent';
-export { watchMulticall, type WatchMulticallConfig, type WatchMulticallCallback, } from './watchMulticall';
-export { watchReadContract, type WatchReadContractConfig, type WatchReadContractCallback, } from './watchReadContract';
-export { watchReadContracts, type WatchReadContractsConfig, type WatchReadContractsCallback, } from './watchReadContracts';
-export { writeContract, type WriteContractArgs, type WriteContractPreparedArgs, type WriteContractResult, type WriteContractUnpreparedArgs, } from './writeContract';

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

@@ -1,17 +0,0 @@
-import { Abi } from 'abitype';
-import { ContractsConfig, ContractsResult, GetOverridesForAbiStateMutability } from '../../types/contracts';
-export declare type MulticallConfig<TContracts extends unknown[]> = {
-    /** Failures in the multicall will fail silently */
-    allowFailure?: boolean;
-    /** Chain id to use for provider */
-    chainId?: number;
-    /** Contracts to query */
-    contracts: readonly [...ContractsConfig<TContracts>];
-    /** Call overrides */
-    overrides?: GetOverridesForAbiStateMutability<'pure'> | GetOverridesForAbiStateMutability<'view'>;
-};
-export declare type MulticallResult<TContracts extends unknown[]> = ContractsResult<TContracts>;
-export 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>>;

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

@@ -1,47 +0,0 @@
-import { Abi, Address, ExtractAbiFunction } from 'abitype';
-import { PopulatedTransaction } from 'ethers/lib/ethers';
-import { Signer } from '../../types';
-import { DefaultOptions, GetConfig, GetOverridesForAbiStateMutability, Options } from '../../types/contracts';
-export declare type PrepareWriteContractConfig<TAbi = Abi, TFunctionName = string, TSigner extends Signer = Signer, TOptions extends Options = DefaultOptions> = GetConfig<{
-    abi: TAbi;
-    functionName: TFunctionName;
-    /** Chain id to use for provider */
-    chainId?: number;
-    /** Overrides */
-    overrides?: GetOverridesForAbiStateMutability<[
-        TAbi,
-        TFunctionName
-    ] extends [
-        infer TAbi_ extends Abi,
-        infer TFunctionName_ extends string
-    ] ? ExtractAbiFunction<TAbi_, TFunctionName_>['stateMutability'] : 'nonpayable' | 'payable'>;
-    /** Custom signer */
-    signer?: TSigner | null;
-}, 'nonpayable' | 'payable', TOptions>;
-export declare type PrepareWriteContractResult<TAbi = Abi, TFunctionName extends string = string> = {
-    abi: TAbi extends Abi ? [ExtractAbiFunction<TAbi, TFunctionName>] : readonly unknown[];
-    address: string;
-    chainId?: number;
-    functionName: TFunctionName;
-    mode: 'prepared';
-    request: PopulatedTransaction & {
-        to: Address;
-        gasLimit: NonNullable<PopulatedTransaction['gasLimit']>;
-    };
-};
-/**
- * @description Prepares the parameters required for a contract write transaction.
- *
- * Returns config to be passed through to `writeContract`.
- *
- * @example
- * import { prepareWriteContract, writeContract } from '@wagmi/core'
- *
- * const config = await prepareWriteContract({
- *  address: '0x...',
- *  abi: wagmiAbi,
- *  functionName: 'mint',
- * })
- * const result = await writeContract(config)
- */
-export 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>>;

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

@@ -1,15 +0,0 @@
-import { Abi } from 'abitype';
-import { DefaultOptions, GetConfig, GetOverridesForAbiStateMutability, GetReturnType, Options } from '../../types/contracts';
-export declare type ReadContractConfig<TAbi = Abi, TFunctionName = string, TOptions extends Options = DefaultOptions> = GetConfig<{
-    abi: TAbi;
-    functionName: TFunctionName;
-    /** Chain id to use for provider */
-    chainId?: number;
-    /** Call overrides */
-    overrides?: GetOverridesForAbiStateMutability<'pure' | 'view'>;
-}, 'pure' | 'view', TOptions>;
-export declare type ReadContractResult<TAbi = Abi, TFunctionName = string> = GetReturnType<{
-    abi: TAbi;
-    functionName: TFunctionName;
-}>;
-export declare function readContract<TAbi extends Abi | readonly unknown[], TFunctionName extends string>({ address, args, chainId, abi, functionName, overrides, }: ReadContractConfig<TAbi, TFunctionName>): Promise<ReadContractResult<TAbi, TFunctionName>>;

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

@@ -1,28 +0,0 @@
-import { Abi } from 'abitype';
-import { ContractsConfig, ContractsResult, DefaultOptions, GetOverridesForAbiStateMutability, Options as Options_ } from '../../types/contracts';
-declare type Options = Options_ & {
-    isContractsOptional?: boolean;
-};
-export declare type ReadContractsConfig<TContracts extends unknown[], TOptions extends Options = DefaultOptions, _Contracts = readonly [
-    ...ContractsConfig<TContracts, {
-        /** Chain id to use for provider */
-        chainId?: number;
-    }, TOptions>
-]> = {
-    /** Failures in the multicall will fail silently */
-    allowFailure?: boolean;
-    /** Call overrides */
-    overrides?: GetOverridesForAbiStateMutability<'pure' | 'view'>;
-} & (TOptions['isContractsOptional'] extends true ? {
-    /** Contracts to query */
-    contracts?: _Contracts;
-} : {
-    /** Contracts to query */
-    contracts: _Contracts;
-});
-export declare type ReadContractsResult<TContracts extends unknown[]> = ContractsResult<TContracts>;
-export 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>>;
-export {};

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

@@ -1,28 +0,0 @@
-import { Abi, AbiEvent, AbiParametersToPrimitiveTypes, ExtractAbiEvent, ExtractAbiEventNames, Narrow } from 'abitype';
-import { Event } from '../../types/contracts';
-import { IsNever, NotEqual, Or } from '../../types/utils';
-declare type ContractEventConfig<TAbi extends Abi | readonly unknown[] = Abi, TEventName extends string = string> = {
-    /** Contract address */
-    address: string;
-    /** Contract ABI */
-    abi: Narrow<TAbi>;
-    /** Chain id to use for provider */
-    chainId?: number;
-    /** Event to listen for */
-    eventName: IsNever<TEventName> extends true ? string : TEventName;
-    /** Receive only a single event */
-    once?: boolean;
-};
-declare 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;
-export declare type WatchContractEventConfig<TAbi = Abi, TEventName = string> = GetConfig<{
-    abi: TAbi;
-    eventName: TEventName;
-}>;
-export 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;
-export declare function watchContractEvent<TAbi extends Abi | readonly unknown[], TEventName extends string>({ address, abi, chainId, eventName, once, }: WatchContractEventConfig<TAbi, TEventName>, callback: WatchContractEventCallback<TAbi, TEventName>): () => void;
-export {};

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

@@ -1,10 +0,0 @@
-import { Abi } from 'abitype';
-import { MulticallConfig, MulticallResult } from './multicall';
-export declare type WatchMulticallConfig<TContracts extends unknown[]> = MulticallConfig<TContracts> & {
-    listenToBlock?: boolean;
-};
-export declare type WatchMulticallCallback<TContracts extends unknown[]> = (results: MulticallResult<TContracts>) => void;
-export declare function watchMulticall<TAbi extends Abi | readonly unknown[], TFunctionName extends string, TContracts extends {
-    abi: TAbi;
-    functionName: TFunctionName;
-}[]>(config: WatchMulticallConfig<TContracts>, callback: WatchMulticallCallback<TContracts>): () => void;

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

@@ -1,7 +0,0 @@
-import { Abi, ExtractAbiFunctionNames } from 'abitype';
-import { ReadContractConfig, ReadContractResult } from './readContract';
-export declare type WatchReadContractConfig<TAbi extends Abi | readonly unknown[] = Abi, TFunctionName extends string = string> = ReadContractConfig<TAbi, TFunctionName> & {
-    listenToBlock?: boolean;
-};
-export declare type WatchReadContractCallback<TAbi extends Abi | readonly unknown[], TFunctionName extends string> = (result: ReadContractResult<TAbi, TFunctionName>) => void;
-export 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;

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

@@ -1,10 +0,0 @@
-import { Abi } from 'abitype';
-import { ReadContractsConfig, ReadContractsResult } from './readContracts';
-export declare type WatchReadContractsConfig<TContracts extends unknown[]> = ReadContractsConfig<TContracts> & {
-    listenToBlock?: boolean;
-};
-export declare type WatchReadContractsCallback<TContracts extends unknown[]> = (results: ReadContractsResult<TContracts>) => void;
-export declare function watchReadContracts<TAbi extends Abi | readonly unknown[], TFunctionName extends string, TContracts extends {
-    abi: TAbi;
-    functionName: TFunctionName;
-}[]>(config: WatchReadContractsConfig<TContracts>, callback: WatchReadContractsCallback<TContracts>): () => void;

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

@@ -1,72 +0,0 @@
-import { Abi, Address, ExtractAbiFunction } from 'abitype';
-import { PopulatedTransaction } from 'ethers';
-import { Signer } from '../../types';
-import { DefaultOptions, GetConfig, GetOverridesForAbiStateMutability, Options as Options_ } from '../../types/contracts';
-import { SendTransactionResult } from '../transactions';
-declare type Options = Options_ & {
-    isRequestOptional?: boolean;
-};
-declare type Request = PopulatedTransaction & {
-    to: Address;
-    gasLimit: NonNullable<PopulatedTransaction['gasLimit']>;
-};
-export declare 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),
-     * it is highly recommended to not use this and instead prepare the request upfront
-     * using the {@link prepareWriteContract} function.
-     *
-     * `prepared`: The request has been prepared with parameters required for sending a transaction
-     * via the {@link prepareWriteContract} function
-     * */
-    mode: 'prepared';
-    args?: never;
-    overrides?: never;
-} & (TOptions['isRequestOptional'] extends true ? {
-    /** The prepared request. */
-    request?: Request;
-} : {
-    /** The prepared request. */
-    request: Request;
-});
-export declare type WriteContractUnpreparedArgs<TAbi = Abi, TFunctionName = string, TOptions extends Options = DefaultOptions> = {
-    mode: 'recklesslyUnprepared';
-    request?: never;
-} & GetConfig<{
-    abi: TAbi;
-    functionName: TFunctionName;
-    /** Call overrides */
-    overrides?: GetOverridesForAbiStateMutability<[
-        TAbi,
-        TFunctionName
-    ] extends [
-        infer TAbi_ extends Abi,
-        infer TFunctionName_ extends string
-    ] ? ExtractAbiFunction<TAbi_, TFunctionName_>['stateMutability'] : 'nonpayable' | 'payable'>;
-}, 'nonpayable' | 'payable', TOptions>;
-export declare type WriteContractArgs<TAbi = Abi, TFunctionName = string, TOptions extends Options = DefaultOptions> = Omit<GetConfig<{
-    abi: TAbi;
-    functionName: TFunctionName;
-    /** Chain id to use for provider */
-    chainId?: number;
-}, 'nonpayable' | 'payable', TOptions>, 'args'> & (WriteContractUnpreparedArgs<TAbi, TFunctionName, TOptions> | WriteContractPreparedArgs<TOptions>);
-export declare 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).
- *
- * @example
- * import { prepareWriteContract, writeContract } from '@wagmi/core'
- *
- * const config = await prepareWriteContract({
- *   address: '0x...',
- *   abi: wagmiAbi,
- *   functionName: 'mint',
- * })
- * const result = await writeContract(config)
- */
-export 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>;
-export {};

package/dist/declarations/src/actions/ens/fetchEnsAddress.d.ts

@@ -1,9 +0,0 @@
-import { Address } from 'abitype';
-export declare type FetchEnsAddressArgs = {
-    /** Chain id to use for provider */
-    chainId?: number;
-    /** ENS name to resolve */
-    name: string;
-};
-export declare type FetchEnsAddressResult = Address | null;
-export declare function fetchEnsAddress({ chainId, name, }: FetchEnsAddressArgs): Promise<FetchEnsAddressResult>;

package/dist/declarations/src/actions/ens/fetchEnsAvatar.d.ts

@@ -1,8 +0,0 @@
-export declare type FetchEnsAvatarArgs = {
-    /** Address or ENS name */
-    addressOrName: string;
-    /** Chain id to use for provider */
-    chainId?: number;
-};
-export declare type FetchEnsAvatarResult = string | null;
-export declare function fetchEnsAvatar({ addressOrName, chainId, }: FetchEnsAvatarArgs): Promise<FetchEnsAvatarResult>;

package/dist/declarations/src/actions/ens/fetchEnsName.d.ts

@@ -1,9 +0,0 @@
-import { Address } from 'abitype';
-export declare type FetchEnsNameArgs = {
-    /** Address to lookup */
-    address: Address;
-    /** Chain id to use for provider */
-    chainId?: number;
-};
-export declare type FetchEnsNameResult = string | null;
-export declare function fetchEnsName({ address, chainId, }: FetchEnsNameArgs): Promise<FetchEnsNameResult>;

package/dist/declarations/src/actions/ens/fetchEnsResolver.d.ts

@@ -1,9 +0,0 @@
-import { providers } from 'ethers';
-export declare type FetchEnsResolverArgs = {
-    /** Chain id to use for provider */
-    chainId?: number;
-    /** ENS name to resolve */
-    name: string;
-};
-export declare type FetchEnsResolverResult = providers.Resolver | null;
-export declare function fetchEnsResolver({ chainId, name, }: FetchEnsResolverArgs): Promise<FetchEnsResolverResult>;

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

@@ -1,4 +0,0 @@
-export { fetchEnsAddress, type FetchEnsAddressArgs, type FetchEnsAddressResult, } from './fetchEnsAddress';
-export { fetchEnsAvatar, type FetchEnsAvatarArgs, type FetchEnsAvatarResult, } from './fetchEnsAvatar';
-export { fetchEnsName, type FetchEnsNameArgs, type FetchEnsNameResult, } from './fetchEnsName';
-export { fetchEnsResolver, type FetchEnsResolverArgs, type FetchEnsResolverResult, } from './fetchEnsResolver';

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

@@ -1,6 +0,0 @@
-export { connect, disconnect, fetchBalance, fetchSigner, getAccount, getNetwork, signMessage, signTypedData, switchNetwork, watchAccount, watchNetwork, watchSigner, type ConnectArgs, type ConnectResult, type FetchBalanceArgs, type FetchBalanceResult, type FetchSignerArgs, type FetchSignerResult, type GetAccountResult, type GetNetworkResult, type SignMessageArgs, type SignMessageResult, type SignTypedDataArgs, type SignTypedDataResult, type SwitchNetworkArgs, type SwitchNetworkResult, type WatchAccountCallback, type WatchNetworkCallback, type WatchSignerCallback, } from './accounts';
-export { fetchToken, getContract, multicall, prepareWriteContract, readContract, readContracts, watchContractEvent, watchMulticall, watchReadContract, watchReadContracts, writeContract, type FetchTokenArgs, type FetchTokenResult, type GetContractArgs, type GetContractResult, type MulticallConfig, type MulticallResult, type PrepareWriteContractConfig, type PrepareWriteContractResult, type ReadContractConfig, type ReadContractResult, type ReadContractsConfig, type ReadContractsResult, type WatchMulticallConfig, type WatchMulticallCallback, type WatchReadContractConfig, type WatchReadContractCallback, type WatchReadContractsConfig, type WatchReadContractsCallback, type WriteContractArgs, type WriteContractPreparedArgs, type WriteContractResult, type WriteContractUnpreparedArgs, } from './contracts';
-export { fetchEnsAddress, fetchEnsAvatar, fetchEnsName, fetchEnsResolver, type FetchEnsAddressArgs, type FetchEnsAddressResult, type FetchEnsAvatarArgs, type FetchEnsAvatarResult, type FetchEnsNameArgs, type FetchEnsNameResult, type FetchEnsResolverArgs, type FetchEnsResolverResult, } from './ens';
-export { fetchBlockNumber, fetchFeeData, watchBlockNumber, type FetchBlockNumberArgs, type FetchBlockNumberResult, type FetchFeeDataArgs, type FetchFeeDataResult, type WatchBlockNumberArgs, type WatchBlockNumberCallback, } from './network-status';
-export { getProvider, getWebSocketProvider, watchProvider, watchWebSocketProvider, type GetProviderArgs, type GetProviderResult, type GetWebSocketProviderArgs, type GetWebSocketProviderResult, type WatchProviderCallback, type WatchWebSocketProviderCallback, } from './providers';
-export { fetchTransaction, prepareSendTransaction, sendTransaction, waitForTransaction, type FetchTransactionArgs, type FetchTransactionResult, type PrepareSendTransactionArgs, type PrepareSendTransactionResult, type SendTransactionArgs, type SendTransactionPreparedRequest, type SendTransactionResult, type SendTransactionUnpreparedRequest, type WaitForTransactionArgs, type WaitForTransactionResult, } from './transactions';

package/dist/declarations/src/actions/network-status/fetchBlockNumber.d.ts

@@ -1,5 +0,0 @@
-export declare type FetchBlockNumberArgs = {
-    chainId?: number;
-};
-export declare type FetchBlockNumberResult = number;
-export declare function fetchBlockNumber({ chainId, }?: FetchBlockNumberArgs): Promise<FetchBlockNumberResult>;

package/dist/declarations/src/actions/network-status/fetchFeeData.d.ts

@@ -1,16 +0,0 @@
-import { providers } from 'ethers';
-import { Unit } from '../../types';
-export declare type FetchFeeDataArgs = {
-    /** Units for formatting output */
-    formatUnits?: Unit | number;
-    /** Chain id to use for provider */
-    chainId?: number;
-};
-export declare type FetchFeeDataResult = providers.FeeData & {
-    formatted: {
-        gasPrice: string | null;
-        maxFeePerGas: string | null;
-        maxPriorityFeePerGas: string | null;
-    };
-};
-export declare function fetchFeeData({ chainId, formatUnits: units, }?: FetchFeeDataArgs): Promise<FetchFeeDataResult>;

package/dist/declarations/src/actions/network-status/index.d.ts

@@ -1,3 +0,0 @@
-export { fetchBlockNumber, type FetchBlockNumberArgs, type FetchBlockNumberResult, } from './fetchBlockNumber';
-export { fetchFeeData, type FetchFeeDataResult, type FetchFeeDataArgs, } from './fetchFeeData';
-export { watchBlockNumber, type WatchBlockNumberArgs, type WatchBlockNumberCallback, } from './watchBlockNumber';

package/dist/declarations/src/actions/network-status/watchBlockNumber.d.ts

@@ -1,7 +0,0 @@
-import { FetchBlockNumberResult } from './fetchBlockNumber';
-export declare type WatchBlockNumberArgs = {
-    chainId?: number;
-    listen: boolean;
-};
-export declare type WatchBlockNumberCallback = (blockNumber: FetchBlockNumberResult) => void;
-export declare function watchBlockNumber(args: WatchBlockNumberArgs, callback: WatchBlockNumberCallback): () => void;

package/dist/declarations/src/actions/providers/getProvider.d.ts

@@ -1,7 +0,0 @@
-import { Provider } from '../../types';
-export declare type GetProviderArgs = {
-    /** Chain id to use for provider */
-    chainId?: number;
-};
-export declare type GetProviderResult<TProvider extends Provider = Provider> = TProvider;
-export declare function getProvider<TProvider extends Provider = Provider>({ chainId, }?: GetProviderArgs): GetProviderResult<TProvider>;

package/dist/declarations/src/actions/providers/getWebSocketProvider.d.ts

@@ -1,7 +0,0 @@
-import { WebSocketProvider } from '../../types';
-export declare type GetWebSocketProviderArgs = {
-    /** Chain id to use for provider */
-    chainId?: number;
-};
-export declare type GetWebSocketProviderResult<TWebSocketProvider extends WebSocketProvider = WebSocketProvider> = TWebSocketProvider | undefined;
-export declare function getWebSocketProvider<TWebSocketProvider extends WebSocketProvider = WebSocketProvider>({ chainId, }?: GetWebSocketProviderArgs): GetWebSocketProviderResult<TWebSocketProvider>;

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

@@ -1,4 +0,0 @@
-export { getProvider, type GetProviderArgs, type GetProviderResult, } from './getProvider';
-export { getWebSocketProvider, type GetWebSocketProviderArgs, type GetWebSocketProviderResult, } from './getWebSocketProvider';
-export { watchProvider, type WatchProviderCallback } from './watchProvider';
-export { watchWebSocketProvider, type WatchWebSocketProviderCallback, } from './watchWebSocketProvider';

package/dist/declarations/src/actions/providers/watchProvider.d.ts

@@ -1,4 +0,0 @@
-import { Provider } from '../../types';
-import { GetProviderArgs, GetProviderResult } from './getProvider';
-export declare type WatchProviderCallback<TProvider extends Provider = Provider> = (provider: GetProviderResult<TProvider>) => void;
-export declare function watchProvider<TProvider extends Provider = Provider>(args: GetProviderArgs, callback: WatchProviderCallback<TProvider>): () => void;

package/dist/declarations/src/actions/providers/watchWebSocketProvider.d.ts

@@ -1,4 +0,0 @@
-import { WebSocketProvider } from '../../types';
-import { GetWebSocketProviderArgs, GetWebSocketProviderResult } from './getWebSocketProvider';
-export declare type WatchWebSocketProviderCallback<TWebSocketProvider extends WebSocketProvider = WebSocketProvider> = (webSocketProvider: GetWebSocketProviderResult<TWebSocketProvider>) => void;
-export declare function watchWebSocketProvider<TWebSocketProvider extends WebSocketProvider = WebSocketProvider>(args: GetWebSocketProviderArgs, callback: WatchWebSocketProviderCallback<TWebSocketProvider>): () => void;

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

@@ -1,21 +0,0 @@
-import { providers } from 'ethers';
-import { Hash } from '../../types';
-export declare type FetchTransactionArgs = {
-    /** Chain ID used to validate if the signer is connected to the target chain */
-    chainId?: number;
-    /** Transaction hash */
-    hash: Hash;
-};
-export declare type FetchTransactionResult = providers.TransactionResponse;
-/**
- * @description Fetches transaction for hash
- *
- * @example
- * import { fetchTransaction } from '@wagmi/core'
- *
- * const transaction = await fetchTransaction({
- *  chainId: 1,
- *  hash: '0x...',
- * })
- */
-export declare function fetchTransaction({ chainId, hash, }: FetchTransactionArgs): Promise<FetchTransactionResult>;

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

@@ -1,4 +0,0 @@
-export { fetchTransaction, type FetchTransactionArgs, type FetchTransactionResult, } from './fetchTransaction';
-export { prepareSendTransaction, type PrepareSendTransactionArgs, type PrepareSendTransactionResult, } from './prepareSendTransaction';
-export { sendTransaction, type SendTransactionArgs, type SendTransactionPreparedRequest, type SendTransactionResult, type SendTransactionUnpreparedRequest, } from './sendTransaction';
-export { waitForTransaction, type WaitForTransactionArgs, type WaitForTransactionResult, } from './waitForTransaction';