@wagmi/core 0.4.0-test.0 → 0.4.0

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

@@ -0,0 +1,36 @@
+import { Client, Data } from '../../client';
+import { Provider } from '../../types';
+export declare type GetAccountResult<TProvider extends Provider = Provider> = {
+    address: NonNullable<Data<TProvider>['account']>;
+    connector: NonNullable<Client<TProvider>['connector']>;
+    isConnected: true;
+    isConnecting: false;
+    isDisconnected: false;
+    isReconnecting: false;
+    status: 'connected';
+} | {
+    address: Data<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';
+};
+export declare function getAccount<TProvider extends Provider>(): GetAccountResult<TProvider>;

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

@@ -0,0 +1,8 @@
+import { Chain } from '../../types';
+export declare type GetNetworkResult = {
+    chain?: Chain & {
+        unsupported?: boolean;
+    };
+    chains: Chain[];
+};
+export declare function getNetwork(): GetNetworkResult;

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

@@ -0,0 +1,12 @@
+export { connect, type ConnectArgs, type ConnectResult } from './connect';
+export { disconnect } from './disconnect';
+export { fetchBalance, type FetchBalanceArgs, type FetchBalanceResult, } from './fetchBalance';
+export { fetchSigner, type FetchSignerResult } from './fetchSigner';
+export { getAccount, type GetAccountResult } from './getAccount';
+export { getNetwork, type GetNetworkResult } from './getNetwork';
+export { signMessage, type SignMessageArgs, type SignMessageResult, } from './signMessage';
+export { signTypedData, type SignTypedDataArgs, type SignTypedDataResult, } from './signTypedData';
+export { switchNetwork, type SwitchNetworkArgs, type SwitchNetworkResult, } from './switchNetwork';
+export { watchAccount, type WatchAccountCallback } from './watchAccount';
+export { watchNetwork, type WatchNetworkCallback } from './watchNetwork';
+export { watchSigner, type WatchSignerCallback } from './watchSigner';

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

@@ -0,0 +1,9 @@
+import { Bytes } from 'ethers/lib/utils';
+export declare type SignMessageArgs = {
+    /** Message to sign with wallet */
+    message: Bytes | string;
+};
+declare type Signature = string;
+export declare type SignMessageResult = Signature;
+export declare function signMessage(args: SignMessageArgs): Promise<SignMessageResult>;
+export {};

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

@@ -0,0 +1,20 @@
+import { BigNumberish, BytesLike } from 'ethers';
+export declare type SignTypedDataArgs = {
+    /** Domain or domain signature for origin or contract */
+    domain: {
+        name?: string;
+        version?: string;
+        chainId?: BigNumberish;
+        verifyingContract?: string;
+        salt?: BytesLike;
+    };
+    /** Named list of all type definitions */
+    types: Record<string, Array<{
+        name: string;
+        type: string;
+    }>>;
+    /** Data to sign */
+    value: Record<string, any>;
+};
+export declare type SignTypedDataResult = string;
+export declare function signTypedData(args: SignTypedDataArgs): Promise<SignTypedDataResult>;

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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,3 @@
+import { FetchSignerResult } from './fetchSigner';
+export declare type WatchSignerCallback = (data: FetchSignerResult) => void;
+export declare function watchSigner(callback: WatchSignerCallback): () => void;

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

@@ -0,0 +1,10 @@
+import { Contract, ContractInterface, Signer, providers } from 'ethers';
+export declare type GetContractArgs = {
+    /** Contract address or ENS name */
+    addressOrName: string;
+    /** Contract interface or ABI */
+    contractInterface: ContractInterface;
+    /** Signer or provider to attach to contract */
+    signerOrProvider?: Signer | providers.Provider | null;
+};
+export declare function getContract<T = Contract>({ addressOrName, contractInterface, signerOrProvider, }: GetContractArgs): T;

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

@@ -0,0 +1,7 @@
+export { getContract, type GetContractArgs } from './getContract';
+export { readContract, type ReadContractConfig, type ReadContractResult, } from './readContract';
+export { readContracts, type ReadContractsConfig, type ReadContractsResult, } from './readContracts';
+export { watchContractEvent } from './watchContractEvent';
+export { watchReadContract, type WatchReadContractConfig, type WatchReadContractResult, } from './watchReadContract';
+export { watchReadContracts, type WatchReadContractsConfig, type WatchReadContractsResult, } from './watchReadContracts';
+export { writeContract, type WriteContractConfig, type WriteContractResult, } from './writeContract';

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

@@ -0,0 +1,21 @@
+import { CallOverrides } from 'ethers/lib/ethers';
+import { Result } from 'ethers/lib/utils';
+import { ReadContractConfig } from './readContract';
+declare type MulticallContract = {
+    addressOrName: ReadContractConfig['addressOrName'];
+    args?: ReadContractConfig['args'];
+    contractInterface: ReadContractConfig['contractInterface'];
+    functionName: ReadContractConfig['functionName'];
+};
+export declare type MulticallConfig = {
+    /** Failures in the multicall will fail silently */
+    allowFailure?: boolean;
+    /** Chain id to use for provider */
+    chainId?: number;
+    contracts: MulticallContract[];
+    /** Call overrides */
+    overrides?: CallOverrides;
+};
+export declare type MulticallResult<Data extends any[] = Result[]> = Data;
+export declare function multicall<Data extends any[] = Result[]>({ allowFailure, chainId, contracts, overrides, }: MulticallConfig): Promise<MulticallResult<Data>>;
+export {};

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

@@ -0,0 +1,17 @@
+import { CallOverrides, Contract } from 'ethers/lib/ethers';
+import { Result } from 'ethers/lib/utils';
+import { GetContractArgs } from './getContract';
+export declare type ReadContractConfig = {
+    addressOrName: GetContractArgs['addressOrName'];
+    /** Arguments to pass contract method */
+    args?: any | any[];
+    /** Chain id to use for provider */
+    chainId?: number;
+    contractInterface: GetContractArgs['contractInterface'];
+    /** Function to invoke on the contract */
+    functionName: string;
+    /** Call overrides */
+    overrides?: CallOverrides;
+};
+export declare type ReadContractResult<Data = Result> = Data;
+export declare function readContract<TContract extends Contract = Contract, Data = Result>({ addressOrName, args, chainId, contractInterface, functionName, overrides, }: ReadContractConfig): Promise<ReadContractResult<Data>>;

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

@@ -0,0 +1,19 @@
+import { CallOverrides } from 'ethers/lib/ethers';
+import { Result } from 'ethers/lib/utils';
+import { ReadContractConfig } from './readContract';
+export declare type ReadContractsContract = {
+    addressOrName: ReadContractConfig['addressOrName'];
+    args?: ReadContractConfig['args'];
+    chainId?: ReadContractConfig['chainId'];
+    contractInterface: ReadContractConfig['contractInterface'];
+    functionName: ReadContractConfig['functionName'];
+};
+export declare type ReadContractsConfig = {
+    /** Failures will fail silently */
+    allowFailure?: boolean;
+    contracts: ReadContractsContract[];
+    /** Call overrides */
+    overrides?: CallOverrides;
+};
+export declare type ReadContractsResult<Data extends any[] = Result[]> = Data;
+export declare function readContracts<Data extends any[] = Result[]>({ allowFailure, contracts, overrides, }: ReadContractsConfig): Promise<ReadContractsResult<Data>>;

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

@@ -0,0 +1,14 @@
+import { Contract } from 'ethers/lib/ethers';
+import { GetContractArgs } from './getContract';
+declare type Config = {
+    /** Chain id to use for provider */
+    chainId?: number;
+    /** Receive only a single event */
+    once?: boolean;
+};
+export declare function watchContractEvent<TContract extends Contract = Contract>(
+/** Contract configuration */
+contractArgs: GetContractArgs, 
+/** Event name to listen to */
+eventName: Parameters<TContract['on']>[0], callback: Parameters<TContract['on']>[1], { chainId, once }?: Config): () => void;
+export {};

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

@@ -0,0 +1,6 @@
+import { ReadContractConfig, ReadContractResult } from './readContract';
+export declare type WatchReadContractConfig = ReadContractConfig & {
+    listenToBlock?: boolean;
+};
+export declare type WatchReadContractResult = (result: ReadContractResult) => void;
+export declare function watchReadContract(config: WatchReadContractConfig, callback: WatchReadContractResult): () => void;

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

@@ -0,0 +1,6 @@
+import { ReadContractsConfig, ReadContractsResult } from './readContracts';
+export declare type WatchReadContractsConfig = ReadContractsConfig & {
+    listenToBlock?: boolean;
+};
+export declare type WatchReadContractsResult = (result: ReadContractsResult) => void;
+export declare function watchReadContracts(config: WatchReadContractsConfig, callback: WatchReadContractsResult): () => void;

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

@@ -0,0 +1,16 @@
+import { CallOverrides, Contract, providers } from 'ethers';
+import { GetContractArgs } from './getContract';
+export declare type WriteContractConfig = GetContractArgs & {
+    /**
+     * Chain id to use for write
+     * If signer is not active on this chain, it will attempt to programmatically switch
+     */
+    chainId?: number;
+    /** Method to call on contract */
+    functionName: string;
+    /** Arguments to pass contract method */
+    args?: any | any[];
+    overrides?: CallOverrides;
+};
+export declare type WriteContractResult = providers.TransactionResponse;
+export declare function writeContract<TContract extends Contract = Contract>({ addressOrName, args, chainId, contractInterface, functionName, overrides, signerOrProvider, }: WriteContractConfig): Promise<WriteContractResult>;

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

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

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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,8 @@
+export declare type FetchEnsNameArgs = {
+    /** Address to lookup */
+    address: string;
+    /** 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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,7 @@
+export { connect, disconnect, fetchBalance, fetchSigner, getAccount, getNetwork, signMessage, signTypedData, switchNetwork, watchAccount, watchNetwork, watchSigner, type ConnectArgs, type ConnectResult, type FetchBalanceArgs, type FetchBalanceResult, 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 { getContract, readContract, readContracts, watchContractEvent, watchReadContract, watchReadContracts, writeContract, type GetContractArgs, type ReadContractConfig, type ReadContractResult, type ReadContractsConfig, type ReadContractsResult, type WatchReadContractConfig, type WatchReadContractResult, type WatchReadContractsConfig, type WatchReadContractsResult, type WriteContractConfig, type WriteContractResult, } 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 { fetchToken, type FetchTokenArgs, type FetchTokenResult, } from './tokens';
+export { sendTransaction, waitForTransaction, type SendTransactionArgs, type SendTransactionResult, type WaitForTransactionArgs, type WaitForTransactionResult, } from './transactions';

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

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,6 @@
+import { FetchBlockNumberResult } from './fetchBlockNumber';
+export declare type WatchBlockNumberArgs = {
+    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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,4 @@
+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/tokens/fetchToken.d.ts

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

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

@@ -0,0 +1 @@
+export { fetchToken, type FetchTokenArgs, type FetchTokenResult, } from './fetchToken';

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

@@ -0,0 +1,2 @@
+export { sendTransaction, type SendTransactionArgs, type SendTransactionResult, } from './sendTransaction';
+export { waitForTransaction, type WaitForTransactionArgs, type WaitForTransactionResult, } from './waitForTransaction';

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

@@ -0,0 +1,12 @@
+import { providers } from 'ethers';
+export declare type SendTransactionArgs = {
+    /**
+     * Chain id to use for write
+     * If signer is not active on this chain, it will attempt to programmatically switch
+     */
+    chainId?: number;
+    /** Object to use when creating transaction */
+    request: providers.TransactionRequest;
+};
+export declare type SendTransactionResult = providers.TransactionResponse;
+export declare function sendTransaction({ chainId, request, }: SendTransactionArgs): Promise<SendTransactionResult>;

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

@@ -0,0 +1,17 @@
+import { providers } from 'ethers';
+export 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?: string;
+    timeout?: number;
+    /** Function resolving to transaction receipt */
+    wait?: providers.TransactionResponse['wait'];
+};
+export declare type WaitForTransactionResult = providers.TransactionReceipt;
+export declare function waitForTransaction({ chainId, confirmations, hash, timeout, wait: wait_, }: WaitForTransactionArgs): Promise<WaitForTransactionResult>;

package/dist/declarations/src/chains.d.ts

@@ -0,0 +1 @@
+export { arbitrum, arbitrumRinkeby, foundry, goerli, hardhat, kovan, localhost, mainnet, optimism, optimismKovan, polygon, polygonMumbai, rinkeby, ropsten, } from './constants/chains';

package/dist/declarations/src/client.d.ts

@@ -0,0 +1,77 @@
+import { Mutate, StoreApi } from 'zustand/vanilla';
+import { Connector, ConnectorData } from './connectors';
+import { ClientStorage } from './storage';
+import { Provider, WebSocketProvider } from './types';
+export 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[];
+    /** 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;
+};
+export declare type Data<TProvider extends Provider> = ConnectorData<TProvider>;
+export declare type State<TProvider extends Provider, TWebSocketProvider extends WebSocketProvider = WebSocketProvider> = {
+    chains?: Connector['chains'];
+    connector?: Connector;
+    connectors: Connector[];
+    data?: Data<TProvider>;
+    error?: Error;
+    provider: TProvider;
+    status: 'connected' | 'connecting' | 'reconnecting' | 'disconnected';
+    webSocketProvider?: TWebSocketProvider;
+};
+export declare class Client<TProvider extends Provider = Provider, TWebSocketProvider extends WebSocketProvider = WebSocketProvider> {
+    #private;
+    config: Partial<ClientConfig<TProvider, TWebSocketProvider>>;
+    storage: ClientStorage;
+    store: Mutate<StoreApi<State<TProvider, TWebSocketProvider>>, [
+        [
+            'zustand/subscribeWithSelector',
+            never
+        ],
+        [
+            'zustand/persist',
+            Partial<State<TProvider, TWebSocketProvider>>
+        ]
+    ]>;
+    constructor({ autoConnect, connectors, provider, storage, webSocketProvider, }: ClientConfig<TProvider, TWebSocketProvider>);
+    get chains(): import("./types").Chain[] | undefined;
+    get connectors(): Connector<any, any>[];
+    get connector(): Connector<any, any> | undefined;
+    get data(): Data<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<TProvider> | undefined>;
+    setLastUsedConnector(lastUsedConnector?: string | null): void;
+}
+export declare let client: Client<Provider, WebSocketProvider>;
+export declare function createClient<TProvider extends Provider = Provider, TWebSocketProvider extends WebSocketProvider = WebSocketProvider>(config: ClientConfig<TProvider, TWebSocketProvider>): Client<TProvider, TWebSocketProvider>;
+export declare function getClient<TProvider extends Provider = Provider, TWebSocketProvider extends WebSocketProvider = WebSocketProvider>(): Client<TProvider, TWebSocketProvider>;

package/dist/declarations/src/connectors/base.d.ts

@@ -0,0 +1,61 @@
+import { default as EventEmitter } from 'eventemitter3';
+import { Signer } from 'ethers/lib/ethers';
+import { Chain } from '../types';
+export declare type ConnectorData<Provider = any> = {
+    account?: string;
+    chain?: {
+        id: number;
+        unsupported: boolean;
+    };
+    provider?: Provider;
+};
+export interface ConnectorEvents<Provider = any> {
+    change(data: ConnectorData<Provider>): void;
+    connect(data: ConnectorData<Provider>): void;
+    message({ type, data }: {
+        type: string;
+        data?: unknown;
+    }): void;
+    disconnect(): void;
+    error(error: Error): void;
+}
+export declare abstract class Connector<Provider = any, Options = any> extends EventEmitter<ConnectorEvents<Provider>> {
+    /** Unique connector id */
+    abstract readonly id: string;
+    /** Connector name */
+    abstract readonly name: string;
+    /** Chains connector supports */
+    readonly chains: Chain[];
+    /** Options to use with connector */
+    readonly options: Options;
+    /** Whether connector is usable */
+    abstract readonly ready: boolean;
+    constructor({ chains, options, }: {
+        chains?: Chain[];
+        options: Options;
+    });
+    abstract connect(config?: {
+        chainId?: number;
+    }): Promise<Required<ConnectorData>>;
+    abstract disconnect(): Promise<void>;
+    abstract getAccount(): Promise<string>;
+    abstract getChainId(): Promise<number>;
+    abstract getProvider(config?: {
+        chainId?: number;
+    }): Promise<Provider>;
+    abstract getSigner(config?: {
+        chainId?: number;
+    }): Promise<Signer>;
+    abstract isAuthorized(): Promise<boolean>;
+    switchChain?(chainId: number): Promise<Chain>;
+    watchAsset?(asset: {
+        address: string;
+        image?: string;
+        symbol: string;
+    }): Promise<boolean>;
+    protected abstract onAccountsChanged(accounts: string[]): void;
+    protected abstract onChainChanged(chain: number | string): void;
+    protected abstract onDisconnect(error: Error): void;
+    protected getBlockExplorerUrls(chain: Chain): any[];
+    protected isChainUnsupported(chainId: number): boolean;
+}