@wagmi/core 0.2.0-next.9 → 0.2.2

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

@@ -0,0 +1,13 @@
+import type { providers } from 'ethers';
+declare type SignTypedData = Parameters<providers.JsonRpcSigner['_signTypedData']>;
+export declare type SignTypedDataArgs = {
+    /** Domain or domain signature for origin or contract */
+    domain: SignTypedData[0];
+    /** Named list of all type definitions */
+    types: SignTypedData[1];
+    /** Data to sign */
+    value: SignTypedData[2];
+};
+export declare type SignTypedDataResult = string;
+export declare function signTypedData(args: SignTypedDataArgs): Promise<SignTypedDataResult>;
+export {};

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,4 @@
+import type { BaseProvider } from '@ethersproject/providers';
+import { GetAccountResult } from './getAccount';
+export declare type WatchAccountCallback<TProvider extends BaseProvider = BaseProvider> = (data: GetAccountResult<TProvider>) => void;
+export declare function watchAccount<TProvider extends BaseProvider>(callback: WatchAccountCallback<TProvider>): () => void;

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

@@ -0,0 +1,3 @@
+import { GetNetworkResult } from './getNetwork';
+export declare type WatchNetworkCallback = (data: GetNetworkResult) => void;
+export declare function watchNetwork(callback: WatchNetworkCallback): () => 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,11 @@
+import type { Provider } from '@ethersproject/providers';
+import { Contract, ContractInterface, Signer } from 'ethers/lib/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 | 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,5 @@
+export { getContract, type GetContractArgs } from './getContract';
+export { readContract, type ReadContractArgs, type ReadContractConfig, type ReadContractResult, } from './readContract';
+export { watchContractEvent } from './watchContractEvent';
+export { watchReadContract, type WatchReadContractArgs, type WatchReadContractConfig, type WatchReadContractResult, } from './watchReadContract';
+export { writeContract, type WriteContractArgs, type WriteContractConfig, type WriteContractResult, } from './writeContract';

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

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

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

@@ -0,0 +1,14 @@
+import { Contract as EthersContract } 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<Contract extends EthersContract = EthersContract>(
+/** Contract configuration */
+contractArgs: GetContractArgs, 
+/** Event name to listen to */
+eventName: Parameters<Contract['on']>[0], callback: Parameters<Contract['on']>[1], { chainId, once }?: Config): () => void;
+export {};

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

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

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

@@ -0,0 +1,11 @@
+import type { TransactionResponse } from '@ethersproject/providers';
+import { CallOverrides, Contract as EthersContract } from 'ethers/lib/ethers';
+import { GetContractArgs } from './getContract';
+export declare type WriteContractArgs = GetContractArgs;
+export declare type WriteContractConfig = {
+    /** Arguments to pass contract method */
+    args?: any | any[];
+    overrides?: CallOverrides;
+};
+export declare type WriteContractResult = TransactionResponse;
+export declare function writeContract<Contract extends EthersContract = EthersContract>(contractConfig: WriteContractArgs, functionName: string, { args, overrides }?: 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 type { Resolver } from '@ethersproject/providers';
+export declare type FetchEnsResolverArgs = {
+    /** Chain id to use for provider */
+    chainId?: number;
+    /** ENS name to resolve */
+    name: string;
+};
+export declare type FetchEnsResolverResult = 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, watchContractEvent, watchReadContract, writeContract, type GetContractArgs, type ReadContractArgs, type ReadContractConfig, type ReadContractResult, type WatchReadContractArgs, type WatchReadContractConfig, type WatchReadContractResult, type WriteContractArgs, 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 type { FeeData } from '@ethersproject/providers';
+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 = FeeData & {
+    formatted: {
+        gasPrice: string;
+        maxFeePerGas: string;
+        maxPriorityFeePerGas: string;
+    };
+};
+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 type { BaseProvider } from '@ethersproject/providers';
+export declare type GetProviderArgs = {
+    /** Chain id to use for provider */
+    chainId?: number;
+};
+export declare type GetProviderResult<TProvider extends BaseProvider = BaseProvider> = TProvider;
+export declare function getProvider<TProvider extends BaseProvider = BaseProvider>({ chainId, }?: GetProviderArgs): GetProviderResult<TProvider>;

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

@@ -0,0 +1,7 @@
+import type { WebSocketProvider } from '@ethersproject/providers';
+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 type { BaseProvider } from '@ethersproject/providers';
+import { GetProviderArgs, GetProviderResult } from './getProvider';
+export declare type WatchProviderCallback<TProvider extends BaseProvider = BaseProvider> = (provider: GetProviderResult<TProvider>) => void;
+export declare function watchProvider<TProvider extends BaseProvider = BaseProvider>(args: GetProviderArgs, callback: WatchProviderCallback<TProvider>): () => void;

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

@@ -0,0 +1,4 @@
+import type { WebSocketProvider } from '@ethersproject/providers';
+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,7 @@
+import type { TransactionRequest, TransactionResponse } from '@ethersproject/providers';
+export declare type SendTransactionArgs = {
+    /** Object to use when creating transaction */
+    request: TransactionRequest;
+};
+export declare type SendTransactionResult = TransactionResponse;
+export declare function sendTransaction(args: SendTransactionArgs): Promise<SendTransactionResult>;

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

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

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

@@ -0,0 +1,81 @@
+import type { BaseProvider, WebSocketProvider } from '@ethersproject/providers';
+import { Mutate, StoreApi } from 'zustand/vanilla';
+import { Connector, ConnectorData } from './connectors';
+import { WagmiStorage } from './storage';
+export declare type ClientConfig<TProvider extends BaseProvider = BaseProvider, TWebSocketProvider extends WebSocketProvider = WebSocketProvider> = {
+    /** Enables reconnecting to last used connector on init */
+    autoConnect?: boolean;
+    /**
+     * Connectors used for linking accounts
+     * @default [new InjectedConnector()]
+     */
+    connectors?: ((config: {
+        chainId?: number;
+    }) => Connector[]) | Connector[];
+    /**
+     * Interface for connecting to network
+     * @default (config) => getDefaultProvider(config.chainId)
+     */
+    provider?: ((config: {
+        chainId?: number;
+    }) => TProvider) | TProvider;
+    /**
+     * Custom storage for data persistance
+     * @default window.localStorage
+     */
+    storage?: WagmiStorage;
+    /** WebSocket interface for connecting to network */
+    webSocketProvider?: ((config: {
+        chainId?: number;
+    }) => TWebSocketProvider | undefined) | TWebSocketProvider;
+};
+export declare type Data<TProvider extends BaseProvider> = ConnectorData<TProvider>;
+export declare type State<TProvider extends BaseProvider, 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 BaseProvider = BaseProvider, TWebSocketProvider extends WebSocketProvider = WebSocketProvider> {
+    #private;
+    config: Partial<ClientConfig<TProvider, TWebSocketProvider>>;
+    storage: WagmiStorage;
+    store: Mutate<StoreApi<State<TProvider, TWebSocketProvider>>, [
+        [
+            'zustand/subscribeWithSelector',
+            never
+        ],
+        [
+            'zustand/persist',
+            Partial<State<TProvider, TWebSocketProvider>>
+        ]
+    ]>;
+    constructor(config?: 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 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<BaseProvider, WebSocketProvider>;
+export declare function createClient<TProvider extends BaseProvider = BaseProvider, TWebSocketProvider extends WebSocketProvider = WebSocketProvider>(config?: ClientConfig<TProvider, TWebSocketProvider>): Client<TProvider, TWebSocketProvider>;
+export declare function getClient<TProvider extends BaseProvider = BaseProvider, TWebSocketProvider extends WebSocketProvider = WebSocketProvider>(): Client<TProvider, TWebSocketProvider>;

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

@@ -0,0 +1,55 @@
+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(): Promise<Required<ConnectorData>>;
+    abstract disconnect(): Promise<void>;
+    abstract getAccount(): Promise<string>;
+    abstract getChainId(): Promise<number>;
+    abstract getProvider(create?: boolean): Promise<Provider>;
+    abstract getSigner(): 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;
+}

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

@@ -0,0 +1,52 @@
+import { providers } from 'ethers';
+import type { CoinbaseWalletProvider } from '@coinbase/wallet-sdk';
+import type { CoinbaseWalletSDKOptions } from '@coinbase/wallet-sdk/dist/CoinbaseWalletSDK';
+import { Chain } from '../types';
+import { Connector } from './base';
+declare type Options = CoinbaseWalletSDKOptions & {
+    /**
+     * Fallback Ethereum JSON RPC URL
+     * @default ""
+     */
+    jsonRpcUrl?: string;
+    /**
+     * Fallback Ethereum Chain ID
+     * @default 1
+     */
+    chainId?: number;
+};
+export declare class CoinbaseWalletConnector extends Connector<CoinbaseWalletProvider, Options> {
+    #private;
+    readonly id = "coinbaseWallet";
+    readonly name = "Coinbase Wallet";
+    readonly ready = true;
+    constructor(config: {
+        chains?: Chain[];
+        options: Options;
+    });
+    connect(): Promise<{
+        account: string;
+        chain: {
+            id: number;
+            unsupported: boolean;
+        };
+        provider: providers.Web3Provider;
+    }>;
+    disconnect(): Promise<void>;
+    getAccount(): Promise<string>;
+    getChainId(): Promise<number>;
+    getProvider(): Promise<CoinbaseWalletProvider>;
+    getSigner(): Promise<providers.JsonRpcSigner>;
+    isAuthorized(): Promise<boolean>;
+    switchChain(chainId: number): Promise<Chain>;
+    watchAsset({ address, decimals, image, symbol, }: {
+        address: string;
+        decimals?: number;
+        image?: string;
+        symbol: string;
+    }): Promise<boolean>;
+    protected onAccountsChanged: (accounts: string[]) => void;
+    protected onChainChanged: (chainId: number | string) => void;
+    protected onDisconnect: () => void;
+}
+export {};

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

@@ -0,0 +1,2 @@
+export { InjectedConnector } from './injected';
+export { Connector, type ConnectorData, type ConnectorEvents } from './base';

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

@@ -0,0 +1,48 @@
+import { providers } from 'ethers';
+import { Chain } from '../types';
+import { Connector } from './base';
+export declare type InjectedConnectorOptions = {
+    /** Name of connector */
+    name?: string | ((detectedName: string | string[]) => string);
+    /**
+     * MetaMask and other injected providers do not support programmatic disconnect.
+     * This flag simulates the disconnect behavior by keeping track of connection status in storage.
+     * @see https://github.com/MetaMask/metamask-extension/issues/10353
+     * @default true
+     */
+    shimDisconnect?: boolean;
+};
+export declare class InjectedConnector extends Connector<Window['ethereum'], InjectedConnectorOptions | undefined> {
+    #private;
+    readonly id: string;
+    readonly name: string;
+    readonly ready: boolean;
+    constructor(config?: {
+        chains?: Chain[];
+        options?: InjectedConnectorOptions;
+    });
+    connect(): Promise<{
+        account: string;
+        chain: {
+            id: number;
+            unsupported: boolean;
+        };
+        provider: Ethereum;
+    }>;
+    disconnect(): Promise<void>;
+    getAccount(): Promise<string>;
+    getChainId(): Promise<number>;
+    getProvider(): Promise<Ethereum | undefined>;
+    getSigner(): Promise<providers.JsonRpcSigner>;
+    isAuthorized(): Promise<boolean>;
+    switchChain(chainId: number): Promise<Chain>;
+    watchAsset({ address, decimals, image, symbol, }: {
+        address: string;
+        decimals?: number;
+        image?: string;
+        symbol: string;
+    }): Promise<any>;
+    protected onAccountsChanged: (accounts: string[]) => void;
+    protected onChainChanged: (chainId: number | string) => void;
+    protected onDisconnect: () => void;
+}

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

@@ -0,0 +1,13 @@
+import { Chain } from '../types';
+import { InjectedConnector, InjectedConnectorOptions } from './injected';
+export declare type MetaMaskConnectorOptions = Pick<InjectedConnectorOptions, 'shimDisconnect'>;
+export declare class MetaMaskConnector extends InjectedConnector {
+    #private;
+    readonly id = "metaMask";
+    readonly ready: boolean;
+    constructor(config?: {
+        chains?: Chain[];
+        options?: MetaMaskConnectorOptions;
+    });
+    getProvider(): Promise<Ethereum | undefined>;
+}

package/dist/declarations/src/connectors/mock/connector.d.ts

@@ -0,0 +1,37 @@
+import { Chain } from '../../types';
+import { Connector } from '../base';
+import { MockProvider, MockProviderOptions } from './provider';
+export declare class MockConnector extends Connector<MockProvider, MockProviderOptions> {
+    #private;
+    readonly id = "mock";
+    readonly name = "Mock";
+    readonly ready = true;
+    constructor(config: {
+        chains?: Chain[];
+        options: MockProviderOptions;
+    });
+    connect(): Promise<{
+        account: string;
+        chain: {
+            id: number;
+            unsupported: boolean;
+        };
+        provider: MockProvider;
+    }>;
+    disconnect(): Promise<void>;
+    getAccount(): Promise<string>;
+    getChainId(): Promise<number>;
+    getProvider(): Promise<MockProvider>;
+    getSigner(): Promise<import("ethers").Signer>;
+    isAuthorized(): Promise<boolean>;
+    watchAsset(asset: {
+        address: string;
+        decimals?: number;
+        image?: string;
+        symbol: string;
+    }): Promise<boolean>;
+    protected onAccountsChanged: (accounts: string[]) => void;
+    protected onChainChanged: (chainId: number | string) => void;
+    protected onDisconnect: () => void;
+    toJSON(): string;
+}

package/dist/declarations/src/connectors/mock/index.d.ts

@@ -0,0 +1,2 @@
+export { MockConnector } from './connector';
+export { type MockProviderOptions, MockProvider } from './provider';