@wagmi/core 0.6.12 → 0.7.0

package/dist/index.d.ts

@@ -0,0 +1,1738 @@
+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 { 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 * as abitype from 'abitype';
+import { Address, ResolvedConfig, TypedDataDomain, Narrow, TypedData, TypedDataToPrimitiveTypes, Abi, ExtractAbiFunction, ExtractAbiEventNames, AbiParametersToPrimitiveTypes, ExtractAbiEvent, AbiFunction, 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-fb6a6ff0.js';
+export { I as InjectedConnector, a as InjectedConnectorOptions } from './injected-6980e5c3.js';
+import 'eventemitter3';
+
+/**
+ * [ERC-20 Token Standard](https://ethereum.org/en/developers/docs/standards/tokens/erc-20)
+ */
+declare const erc20ABI: readonly [{
+    readonly type: "event";
+    readonly name: "Approval";
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly name: "owner";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly name: "spender";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly name: "value";
+        readonly type: "uint256";
+    }];
+}, {
+    readonly type: "event";
+    readonly name: "Transfer";
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly name: "from";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly name: "to";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly name: "value";
+        readonly type: "uint256";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "allowance";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+    }, {
+        readonly name: "spender";
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "approve";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly name: "spender";
+        readonly type: "address";
+    }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bool";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "balanceOf";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly name: "account";
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "decimals";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint8";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "name";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "string";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "symbol";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "string";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "totalSupply";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "transfer";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly name: "recipient";
+        readonly type: "address";
+    }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bool";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "transferFrom";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly name: "sender";
+        readonly type: "address";
+    }, {
+        readonly name: "recipient";
+        readonly type: "address";
+    }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bool";
+    }];
+}];
+/**
+ * [ERC-721 Non-Fungible Token Standard](https://ethereum.org/en/developers/docs/standards/tokens/erc-721)
+ */
+declare const erc721ABI: readonly [{
+    readonly type: "event";
+    readonly name: "Approval";
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly name: "owner";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly name: "spender";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly name: "tokenId";
+        readonly type: "uint256";
+    }];
+}, {
+    readonly type: "event";
+    readonly name: "ApprovalForAll";
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly name: "owner";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly name: "operator";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly name: "approved";
+        readonly type: "bool";
+    }];
+}, {
+    readonly type: "event";
+    readonly name: "Transfer";
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly name: "from";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly name: "to";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly name: "tokenId";
+        readonly type: "uint256";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "approve";
+    readonly stateMutability: "payable";
+    readonly inputs: readonly [{
+        readonly name: "spender";
+        readonly type: "address";
+    }, {
+        readonly name: "tokenId";
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [];
+}, {
+    readonly type: "function";
+    readonly name: "balanceOf";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly name: "account";
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "getApproved";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly name: "tokenId";
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "isApprovedForAll";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+    }, {
+        readonly name: "operator";
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bool";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "name";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "string";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "ownerOf";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly name: "tokenId";
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "safeTransferFrom";
+    readonly stateMutability: "payable";
+    readonly inputs: readonly [{
+        readonly name: "from";
+        readonly type: "address";
+    }, {
+        readonly name: "to";
+        readonly type: "address";
+    }, {
+        readonly name: "tokenId";
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [];
+}, {
+    readonly type: "function";
+    readonly name: "safeTransferFrom";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly name: "from";
+        readonly type: "address";
+    }, {
+        readonly name: "to";
+        readonly type: "address";
+    }, {
+        readonly name: "id";
+        readonly type: "uint256";
+    }, {
+        readonly name: "data";
+        readonly type: "bytes";
+    }];
+    readonly outputs: readonly [];
+}, {
+    readonly type: "function";
+    readonly name: "setApprovalForAll";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly name: "operator";
+        readonly type: "address";
+    }, {
+        readonly name: "approved";
+        readonly type: "bool";
+    }];
+    readonly outputs: readonly [];
+}, {
+    readonly type: "function";
+    readonly name: "symbol";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "string";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "tokenByIndex";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly name: "index";
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "tokenByIndex";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+    }, {
+        readonly name: "index";
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "tokenId";
+        readonly type: "uint256";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "tokenURI";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly name: "tokenId";
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "string";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "totalSupply";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "transferFrom";
+    readonly stateMutability: "payable";
+    readonly inputs: readonly [{
+        readonly name: "sender";
+        readonly type: "address";
+    }, {
+        readonly name: "recipient";
+        readonly type: "address";
+    }, {
+        readonly name: "tokeId";
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [];
+}];
+/**
+ * [ERC-4626 Tokenized Vaults Standard](https://ethereum.org/en/developers/docs/standards/tokens/erc-4626)
+ */
+declare const erc4626ABI: readonly [{
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly name: "owner";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly name: "spender";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly name: "value";
+        readonly type: "uint256";
+    }];
+    readonly name: "Approval";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly name: "sender";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly name: "receiver";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly name: "assets";
+        readonly type: "uint256";
+    }, {
+        readonly indexed: false;
+        readonly name: "shares";
+        readonly type: "uint256";
+    }];
+    readonly name: "Deposit";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly name: "from";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly name: "to";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly name: "value";
+        readonly type: "uint256";
+    }];
+    readonly name: "Transfer";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly name: "sender";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly name: "receiver";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly name: "owner";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly name: "assets";
+        readonly type: "uint256";
+    }, {
+        readonly indexed: false;
+        readonly name: "shares";
+        readonly type: "uint256";
+    }];
+    readonly name: "Withdraw";
+    readonly type: "event";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+    }, {
+        readonly name: "spender";
+        readonly type: "address";
+    }];
+    readonly name: "allowance";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "spender";
+        readonly type: "address";
+    }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+    }];
+    readonly name: "approve";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "asset";
+    readonly outputs: readonly [{
+        readonly name: "assetTokenAddress";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "account";
+        readonly type: "address";
+    }];
+    readonly name: "balanceOf";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "shares";
+        readonly type: "uint256";
+    }];
+    readonly name: "convertToAssets";
+    readonly outputs: readonly [{
+        readonly name: "assets";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "assets";
+        readonly type: "uint256";
+    }];
+    readonly name: "convertToShares";
+    readonly outputs: readonly [{
+        readonly name: "shares";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "assets";
+        readonly type: "uint256";
+    }, {
+        readonly name: "receiver";
+        readonly type: "address";
+    }];
+    readonly name: "deposit";
+    readonly outputs: readonly [{
+        readonly name: "shares";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "caller";
+        readonly type: "address";
+    }];
+    readonly name: "maxDeposit";
+    readonly outputs: readonly [{
+        readonly name: "maxAssets";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "caller";
+        readonly type: "address";
+    }];
+    readonly name: "maxMint";
+    readonly outputs: readonly [{
+        readonly name: "maxShares";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+    }];
+    readonly name: "maxRedeem";
+    readonly outputs: readonly [{
+        readonly name: "maxShares";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+    }];
+    readonly name: "maxWithdraw";
+    readonly outputs: readonly [{
+        readonly name: "maxAssets";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "shares";
+        readonly type: "uint256";
+    }, {
+        readonly name: "receiver";
+        readonly type: "address";
+    }];
+    readonly name: "mint";
+    readonly outputs: readonly [{
+        readonly name: "assets";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "assets";
+        readonly type: "uint256";
+    }];
+    readonly name: "previewDeposit";
+    readonly outputs: readonly [{
+        readonly name: "shares";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "shares";
+        readonly type: "uint256";
+    }];
+    readonly name: "previewMint";
+    readonly outputs: readonly [{
+        readonly name: "assets";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "shares";
+        readonly type: "uint256";
+    }];
+    readonly name: "previewRedeem";
+    readonly outputs: readonly [{
+        readonly name: "assets";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "assets";
+        readonly type: "uint256";
+    }];
+    readonly name: "previewWithdraw";
+    readonly outputs: readonly [{
+        readonly name: "shares";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "shares";
+        readonly type: "uint256";
+    }, {
+        readonly name: "receiver";
+        readonly type: "address";
+    }, {
+        readonly name: "owner";
+        readonly type: "address";
+    }];
+    readonly name: "redeem";
+    readonly outputs: readonly [{
+        readonly name: "assets";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "totalAssets";
+    readonly outputs: readonly [{
+        readonly name: "totalManagedAssets";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "totalSupply";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "to";
+        readonly type: "address";
+    }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+    }];
+    readonly name: "transfer";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "from";
+        readonly type: "address";
+    }, {
+        readonly name: "to";
+        readonly type: "address";
+    }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+    }];
+    readonly name: "transferFrom";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "assets";
+        readonly type: "uint256";
+    }, {
+        readonly name: "receiver";
+        readonly type: "address";
+    }, {
+        readonly name: "owner";
+        readonly type: "address";
+    }];
+    readonly name: "withdraw";
+    readonly outputs: readonly [{
+        readonly name: "shares";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}];
+
+declare type BaseStorage = Pick<Storage, 'getItem' | 'setItem' | 'removeItem'>;
+declare 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;
+    key?: string;
+}): ClientStorage;
+
+declare type ClientConfig<TProvider extends Provider = Provider, TWebSocketProvider extends WebSocketProvider = WebSocketProvider> = {
+    /** Enables reconnecting to last used connector on init */
+    autoConnect?: boolean;
+    /**
+     * Connectors used for linking accounts
+     * @default [new InjectedConnector()]
+     */
+    connectors?: (() => Connector[]) | Connector[];
+    /** Custom logger */
+    logger?: {
+        warn: typeof console.warn | null;
+    };
+    /** Interface for connecting to network */
+    provider: ((config: {
+        chainId?: number;
+    }) => TProvider) | TProvider;
+    /**
+     * Custom storage for data persistance
+     * @default window.localStorage
+     */
+    storage?: ClientStorage;
+    /** WebSocket interface for connecting to network */
+    webSocketProvider?: ((config: {
+        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> = {
+    chains?: Connector['chains'];
+    connector?: Connector;
+    connectors: Connector[];
+    data?: Data$1<TProvider>;
+    error?: Error;
+    provider: TProvider;
+    status: 'connected' | 'connecting' | 'reconnecting' | 'disconnected';
+    webSocketProvider?: TWebSocketProvider;
+};
+declare class Client<TProvider extends Provider = Provider, TWebSocketProvider extends WebSocketProvider = WebSocketProvider> {
+    #private;
+    config: ClientConfig<TProvider, TWebSocketProvider>;
+    providers: Map<number, TProvider | undefined>;
+    storage: ClientStorage;
+    store: Mutate<StoreApi<State<TProvider, TWebSocketProvider>>, [
+        [
+            'zustand/subscribeWithSelector',
+            never
+        ],
+        [
+            'zustand/persist',
+            Partial<State<TProvider, TWebSocketProvider>>
+        ]
+    ]>;
+    webSocketProviders: Map<number, TWebSocketProvider | undefined>;
+    constructor({ autoConnect, connectors, provider, storage, logger, webSocketProvider, }: ClientConfig<TProvider, TWebSocketProvider>);
+    get chains(): Chain[] | undefined;
+    get connectors(): Connector<any, any, any>[];
+    get connector(): Connector<any, any, any> | undefined;
+    get data(): Data$1<TProvider> | undefined;
+    get error(): Error | undefined;
+    get lastUsedChainId(): number | undefined;
+    get provider(): TProvider;
+    get status(): "connecting" | "connected" | "reconnecting" | "disconnected";
+    get subscribe(): {
+        (listener: (selectedState: State<TProvider, TWebSocketProvider>, previousSelectedState: State<TProvider, TWebSocketProvider>) => void): () => void;
+        <U>(selector: (state: State<TProvider, TWebSocketProvider>) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
+            equalityFn?: ((a: U, b: U) => boolean) | undefined;
+            fireImmediately?: boolean | undefined;
+        } | undefined): () => void;
+    };
+    get webSocketProvider(): TWebSocketProvider | undefined;
+    setState(updater: State<TProvider, TWebSocketProvider> | ((state: State<TProvider, TWebSocketProvider>) => State<TProvider, TWebSocketProvider>)): void;
+    clearState(): void;
+    destroy(): Promise<void>;
+    autoConnect(): Promise<Data$1<TProvider> | undefined>;
+    getProvider({ bust, chainId }?: {
+        bust?: boolean;
+        chainId?: number;
+    }): TProvider;
+    getWebSocketProvider({ bust, chainId, }?: {
+        bust?: boolean;
+        chainId?: number;
+    }): TWebSocketProvider | undefined;
+    setLastUsedConnector(lastUsedConnector?: string | null): void;
+}
+declare function createClient<TProvider extends Provider = Provider, TWebSocketProvider extends WebSocketProvider = WebSocketProvider>(config: ClientConfig<TProvider, TWebSocketProvider>): Client<TProvider, TWebSocketProvider>;
+
+declare 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> = {
+    account: Data<TProvider>['account'];
+    chain: Data<TProvider>['chain'];
+    connector: Client<TProvider>['connector'];
+    provider: Data<TProvider>['provider'];
+};
+declare function connect<TProvider extends Provider = Provider>({ chainId, connector, }: ConnectArgs): Promise<ConnectResult<TProvider>>;
+
+declare function disconnect(): Promise<void>;
+
+declare type FetchBalanceArgs = {
+    /** Address of balance to check */
+    address: Address;
+    /** Chain id to use for provider */
+    chainId?: number;
+    /** Units for formatting output */
+    formatUnits?: Unit | number;
+    /** ERC-20 address */
+    token?: Address;
+};
+declare type FetchBalanceResult = {
+    decimals: ResolvedConfig['IntType'];
+    formatted: string;
+    symbol: string;
+    value: ResolvedConfig['BigIntType'];
+};
+declare function fetchBalance({ address, chainId, formatUnits: unit, token, }: FetchBalanceArgs): Promise<FetchBalanceResult>;
+
+declare type FetchSignerArgs = {
+    /** Chain ID to use for signer */
+    chainId?: number;
+};
+declare 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> = {
+    address: NonNullable<Data$1<TProvider>['account']>;
+    connector: NonNullable<Client<TProvider>['connector']>;
+    isConnected: true;
+    isConnecting: false;
+    isDisconnected: false;
+    isReconnecting: false;
+    status: 'connected';
+} | {
+    address: Data$1<TProvider>['account'];
+    connector: Client<TProvider>['connector'];
+    isConnected: boolean;
+    isConnecting: false;
+    isDisconnected: false;
+    isReconnecting: true;
+    status: 'reconnecting';
+} | {
+    address: undefined;
+    connector: undefined;
+    isConnected: false;
+    isReconnecting: false;
+    isConnecting: true;
+    isDisconnected: false;
+    status: 'connecting';
+} | {
+    address: undefined;
+    connector: undefined;
+    isConnected: false;
+    isReconnecting: false;
+    isConnecting: false;
+    isDisconnected: true;
+    status: 'disconnected';
+};
+declare function getAccount<TProvider extends Provider>(): GetAccountResult<TProvider>;
+
+declare type GetNetworkResult = {
+    chain?: Chain & {
+        unsupported?: boolean;
+    };
+    chains: Chain[];
+};
+declare function getNetwork(): GetNetworkResult;
+
+declare type SignMessageArgs = {
+    /** Message to sign with wallet */
+    message: string | Uint8Array;
+};
+declare type SignMessageResult = ResolvedConfig['BytesType'];
+declare function signMessage(args: SignMessageArgs): Promise<SignMessageResult>;
+
+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);
+declare type SignTypedDataResult = string;
+declare function signTypedData<TTypedData extends TypedData>({ domain, types, value, }: SignTypedDataArgs<TTypedData>): Promise<SignTypedDataResult>;
+
+declare type SwitchNetworkArgs = {
+    chainId: number;
+};
+declare type SwitchNetworkResult = Chain;
+declare function switchNetwork({ chainId, }: SwitchNetworkArgs): Promise<SwitchNetworkResult>;
+
+declare type WatchAccountCallback<TProvider extends Provider = Provider> = (data: GetAccountResult<TProvider>) => void;
+declare type WatchAccountConfig = {
+    selector?({ address, connector, status, }: {
+        address?: string;
+        connector?: Connector;
+        status: GetAccountResult['status'];
+    }): any;
+};
+declare function watchAccount<TProvider extends Provider>(callback: WatchAccountCallback<TProvider>, { selector }?: WatchAccountConfig): () => void;
+
+declare type WatchNetworkCallback = (data: GetNetworkResult) => void;
+declare type WatchNetworkConfig = {
+    selector?({ chainId, chains }: {
+        chainId?: number;
+        chains?: Chain[];
+    }): any;
+};
+declare function watchNetwork(callback: WatchNetworkCallback, { selector }?: WatchNetworkConfig): () => void;
+
+declare type WatchSignerArgs = FetchSignerArgs;
+declare 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 = {
+    /** Address of ERC-20 token */
+    address: Address;
+    /** Chain id to use for provider */
+    chainId?: number;
+    /** Units for formatting output */
+    formatUnits?: Unit | number;
+};
+declare type FetchTokenResult = {
+    address: Address;
+    decimals: ResolvedConfig['IntType'];
+    name: string;
+    symbol: string;
+    totalSupply: {
+        formatted: string;
+        value: ResolvedConfig['BigIntType'];
+    };
+};
+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<{
+    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>;
+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)
+ */
+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> = {
+    /** Contract address */
+    address: string;
+    /** Contract ABI */
+    abi: Narrow<TAbi>;
+    /** 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;
+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<{
+    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]>;
+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]>;
+
+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'>;
+};
+declare 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<{
+    abi: TAbi;
+    functionName: TFunctionName;
+    /** Chain id to use for provider */
+    chainId?: number;
+    /** Call overrides */
+    overrides?: GetOverridesForAbiStateMutability<'pure' | 'view'>;
+}, 'pure' | 'view', TOptions>;
+declare 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 & {
+    isContractsOptional?: boolean;
+};
+declare type ReadContractsConfig<TContracts extends unknown[], TOptions extends Options$1 = 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;
+});
+declare 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> = {
+    /** 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;
+declare 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;
+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> & {
+    listenToBlock?: boolean;
+};
+declare 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> & {
+    listenToBlock?: boolean;
+};
+declare 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> & {
+    listenToBlock?: boolean;
+};
+declare 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 = {
+    /** 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;
+/**
+ * @description Fetches transaction for hash
+ *
+ * @example
+ * import { fetchTransaction } from '@wagmi/core'
+ *
+ * const transaction = await fetchTransaction({
+ *  chainId: 1,
+ *  hash: '0x...',
+ * })
+ */
+declare function fetchTransaction({ chainId, hash, }: FetchTransactionArgs): Promise<FetchTransactionResult>;
+
+declare 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 */
+    request: providers.TransactionRequest & {
+        to: NonNullable<providers.TransactionRequest['to']>;
+    };
+    signer?: TSigner | null;
+};
+declare type PrepareSendTransactionResult = {
+    chainId?: number;
+    request: providers.TransactionRequest & {
+        to: Address;
+        gasLimit: NonNullable<providers.TransactionRequest['gasLimit']>;
+    };
+    mode: 'prepared';
+};
+/**
+ * @description Prepares the parameters required for sending a transaction.
+ *
+ * Returns config to be passed through to `sendTransaction`.
+ *
+ * @example
+ * import { prepareSendTransaction, sendTransaction } from '@wagmi/core'
+ *
+ * const config = await prepareSendTransaction({
+ *  request: {
+ *    to: 'moxey.eth',
+ *    value: parseEther('1'),
+ *  }
+ * })
+ * const result = await sendTransaction(config)
+ */
+declare function prepareSendTransaction({ chainId, request, signer: signer_, }: PrepareSendTransactionArgs): Promise<PrepareSendTransactionResult>;
+
+declare 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
+     * to not use this and instead prepare the request upfront using the `prepareSendTransaction` function.
+     *
+     * `prepared`: The request has been prepared with parameters required for sending a transaction
+     * via the `prepareSendTransaction` function
+     * */
+    mode: 'prepared';
+    /** The prepared request for sending a transaction. */
+    request: providers.TransactionRequest & {
+        to: Address;
+        gasLimit: NonNullable<providers.TransactionRequest['gasLimit']>;
+    };
+};
+declare type SendTransactionUnpreparedRequest = {
+    mode: 'recklesslyUnprepared';
+    /** The unprepared request for sending a transaction. */
+    request: providers.TransactionRequest;
+};
+declare type SendTransactionArgs = {
+    /** Chain ID used to validate if the signer is connected to the target chain */
+    chainId?: number;
+} & (SendTransactionPreparedRequest | SendTransactionUnpreparedRequest);
+declare type SendTransactionResult = {
+    hash: Hash;
+    wait: providers.TransactionResponse['wait'];
+};
+/**
+ * @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).
+ *
+ * @example
+ * import { prepareSendTransaction, sendTransaction } from '@wagmi/core'
+ *
+ * const config = await prepareSendTransaction({
+ *  to: 'moxey.eth',
+ *  value: parseEther('1'),
+ * })
+ * const result = await sendTransaction(config)
+ */
+declare function sendTransaction({ chainId, mode, request, }: SendTransactionArgs): Promise<SendTransactionResult>;
+
+declare type WaitForTransactionArgs = {
+    /** Chain id to use for provider */
+    chainId?: number;
+    /**
+     * Number of blocks to wait for after transaction is mined
+     * @default 1
+     */
+    confirmations?: number;
+    /** Transaction hash to monitor */
+    hash?: Hash;
+    timeout?: number;
+    /** Function resolving to transaction receipt */
+    wait?: providers.TransactionResponse['wait'];
+};
+declare type WaitForTransactionResult = providers.TransactionReceipt;
+declare function waitForTransaction({ chainId, confirmations, hash, timeout, wait: wait_, }: WaitForTransactionArgs): Promise<WaitForTransactionResult>;
+
+declare type Options = Options$2 & {
+    isRequestOptional?: boolean;
+};
+declare type Request = PopulatedTransaction & {
+    to: Address;
+    gasLimit: NonNullable<PopulatedTransaction['gasLimit']>;
+};
+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;
+});
+declare type WriteContractUnpreparedArgs<TAbi = Abi, TFunctionName = string, TOptions extends Options = DefaultOptions> = {
+    mode: 'recklesslyUnprepared';
+    request?: never;
+} & GetConfig$1<{
+    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>;
+declare 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;
+/**
+ * @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)
+ */
+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 = {
+    /** Chain id to use for provider */
+    chainId?: number;
+    /** ENS name to resolve */
+    name: string;
+};
+declare type FetchEnsAddressResult = Address | null;
+declare function fetchEnsAddress({ chainId, name, }: FetchEnsAddressArgs): Promise<FetchEnsAddressResult>;
+
+declare type FetchEnsAvatarArgs = {
+    /** Address or ENS name */
+    address: Address;
+    /** Chain id to use for provider */
+    chainId?: number;
+};
+declare type FetchEnsAvatarResult = string | null;
+declare function fetchEnsAvatar({ address, chainId, }: FetchEnsAvatarArgs): Promise<FetchEnsAvatarResult>;
+
+declare type FetchEnsNameArgs = {
+    /** Address to lookup */
+    address: Address;
+    /** Chain id to use for provider */
+    chainId?: number;
+};
+declare type FetchEnsNameResult = string | null;
+declare function fetchEnsName({ address, chainId, }: FetchEnsNameArgs): Promise<FetchEnsNameResult>;
+
+declare type FetchEnsResolverArgs = {
+    /** Chain id to use for provider */
+    chainId?: number;
+    /** ENS name to resolve */
+    name: string;
+};
+declare type FetchEnsResolverResult = providers.Resolver | null;
+declare function fetchEnsResolver({ chainId, name, }: FetchEnsResolverArgs): Promise<FetchEnsResolverResult>;
+
+declare type FetchBlockNumberArgs = {
+    chainId?: number;
+};
+declare type FetchBlockNumberResult = number;
+declare function fetchBlockNumber({ chainId, }?: FetchBlockNumberArgs): Promise<FetchBlockNumberResult>;
+
+declare type FetchFeeDataArgs = {
+    /** Units for formatting output */
+    formatUnits?: Unit | number;
+    /** Chain id to use for provider */
+    chainId?: number;
+};
+declare type FetchFeeDataResult = providers.FeeData & {
+    formatted: {
+        gasPrice: string | null;
+        maxFeePerGas: string | null;
+        maxPriorityFeePerGas: string | null;
+    };
+};
+declare function fetchFeeData({ chainId, formatUnits: units, }?: FetchFeeDataArgs): Promise<FetchFeeDataResult>;
+
+declare type WatchBlockNumberArgs = {
+    chainId?: number;
+    listen: boolean;
+};
+declare type WatchBlockNumberCallback = (blockNumber: FetchBlockNumberResult) => void;
+declare function watchBlockNumber(args: WatchBlockNumberArgs, callback: WatchBlockNumberCallback): () => void;
+
+declare type GetProviderArgs = {
+    /** Chain id to use for provider */
+    chainId?: number;
+};
+declare type GetProviderResult<TProvider extends Provider = Provider> = TProvider;
+declare function getProvider<TProvider extends Provider = Provider>({ chainId, }?: GetProviderArgs): GetProviderResult<TProvider>;
+
+declare type GetWebSocketProviderArgs = {
+    /** Chain id to use for provider */
+    chainId?: number;
+};
+declare 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;
+declare function watchProvider<TProvider extends Provider = Provider>(args: GetProviderArgs, callback: WatchProviderCallback<TProvider>): () => void;
+
+declare type WatchWebSocketProviderCallback<TWebSocketProvider extends WebSocketProvider = WebSocketProvider> = (webSocketProvider: GetWebSocketProviderResult<TWebSocketProvider>) => void;
+declare function watchWebSocketProvider<TWebSocketProvider extends WebSocketProvider = WebSocketProvider>(args: GetWebSocketProviderArgs, callback: WatchWebSocketProviderCallback<TWebSocketProvider>): () => void;
+
+/**
+ * Error subclass implementing JSON RPC 2.0 errors and Ethereum RPC errors per EIP-1474.
+ * @see https://eips.ethereum.org/EIPS/eip-1474
+ */
+declare class RpcError<T = undefined> extends Error {
+    readonly code: number;
+    readonly data?: T;
+    readonly internal?: unknown;
+    constructor(
+    /** Number error code */
+    code: number, 
+    /** Human-readable string */
+    message: string, 
+    /** Low-level error */
+    internal?: unknown, 
+    /** Other useful information about error */
+    data?: T);
+}
+/**
+ * Error subclass implementing Ethereum Provider errors per EIP-1193.
+ * @see https://eips.ethereum.org/EIPS/eip-1193
+ */
+declare class ProviderRpcError<T = undefined> extends RpcError<T> {
+    /**
+     * Create an Ethereum Provider JSON-RPC error.
+     * `code` must be an integer in the 1000 <= 4999 range.
+     */
+    constructor(
+    /**
+     * Number error code
+     * @see https://eips.ethereum.org/EIPS/eip-1193#error-standards
+     */
+    code: 4001 | 4100 | 4200 | 4900 | 4901 | 4902, 
+    /** Human-readable string */
+    message: string, 
+    /** Low-level error */
+    internal?: unknown, 
+    /** Other useful information about error */
+    data?: T);
+}
+declare class AddChainError extends Error {
+    name: string;
+    message: string;
+}
+declare class ChainDoesNotSupportMulticallError extends Error {
+    name: string;
+    constructor({ blockNumber, chain }: {
+        blockNumber?: number;
+        chain: Chain;
+    });
+}
+declare class ChainMismatchError extends Error {
+    name: string;
+    constructor({ activeChain, targetChain, }: {
+        activeChain: string;
+        targetChain: string;
+    });
+}
+declare class ChainNotConfiguredError extends Error {
+    name: string;
+    constructor({ chainId, connectorId, }: {
+        chainId: number;
+        connectorId: string;
+    });
+}
+declare class ConnectorAlreadyConnectedError extends Error {
+    name: string;
+    message: string;
+}
+declare class ConnectorNotFoundError extends Error {
+    name: string;
+    message: string;
+}
+declare class ContractMethodDoesNotExistError extends Error {
+    name: string;
+    constructor({ address, chainId, functionName, }: {
+        address: string;
+        chainId?: number;
+        functionName: string;
+    });
+}
+declare class ContractMethodNoResultError extends Error {
+    name: string;
+    constructor({ address, args, chainId, functionName, }: {
+        address: string;
+        args: any;
+        chainId: number;
+        functionName: string;
+    });
+}
+declare class ContractMethodRevertedError extends Error {
+    name: string;
+    constructor({ address, args, chainId, functionName, errorMessage, }: {
+        address: string;
+        args: any;
+        chainId: number;
+        functionName: string;
+        errorMessage: string;
+    });
+}
+declare class ContractResultDecodeError extends Error {
+    name: string;
+    constructor({ address, args, chainId, functionName, errorMessage, }: {
+        address: string;
+        args: any;
+        chainId: number;
+        functionName: string;
+        errorMessage: string;
+    });
+}
+declare class ProviderChainsNotFound extends Error {
+    name: string;
+    message: string;
+}
+declare class ResourceUnavailableError extends RpcError {
+    name: string;
+    constructor(error: unknown);
+}
+declare class SwitchChainError extends ProviderRpcError {
+    name: string;
+    constructor(error: unknown);
+}
+declare class SwitchChainNotSupportedError extends Error {
+    name: string;
+    constructor({ connector }: {
+        connector: Connector;
+    });
+}
+declare class UserRejectedRequestError extends ProviderRpcError {
+    name: string;
+    constructor(error: unknown);
+}
+
+declare type ConfigureChainsConfig = {
+    pollingInterval?: number;
+    stallTimeout?: number;
+} & ({
+    targetQuorum?: number;
+    minQuorum?: never;
+} | {
+    targetQuorum: number;
+    minQuorum?: number;
+});
+declare function configureChains<TProvider extends Provider = Provider, TWebSocketProvider extends WebSocketProvider = WebSocketProvider, TChain extends Chain = Chain>(defaultChains: TChain[], providers: ChainProviderFn<TProvider, TWebSocketProvider, TChain>[], { minQuorum, pollingInterval, targetQuorum, stallTimeout, }?: ConfigureChainsConfig): {
+    readonly chains: TChain[];
+    readonly provider: ({ chainId }: {
+        chainId?: number | undefined;
+    }) => (ProviderWithFallbackConfig<TProvider> | providers.FallbackProvider) & {
+        chains: TChain[];
+        pollingInterval: number;
+    };
+    readonly webSocketProvider: ({ chainId }: {
+        chainId?: number | undefined;
+    }) => (TWebSocketProvider & {
+        chains: TChain[];
+    }) | undefined;
+};
+
+/** Forked from https://github.com/epoberezkin/fast-deep-equal */
+declare function deepEqual(a: any, b: any): boolean;
+
+declare function minimizeContractInterface<TAbi extends Abi | readonly unknown[]>(config: {
+    abi: TAbi;
+    functionName: TAbi extends Abi ? ExtractAbiFunctionNames<TAbi> : string;
+}): string[] | (abitype.AbiFunction | abitype.AbiEvent | abitype.AbiError)[];
+
+declare function normalizeChainId(chainId: string | number | bigint): number;
+
+declare function parseContractResult({ abi, data, functionName, }: {
+    abi: ContractInterface | Abi | readonly unknown[];
+    data: any;
+    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 };