@wagmi/core 0.2.0-next.7 → 0.2.0

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

@@ -1,7 +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({ name, }: FetchEnsResolverArgs): Promise<FetchEnsResolverResult>;
+export declare function fetchEnsResolver({ chainId, name, }: FetchEnsResolverArgs): Promise<FetchEnsResolverResult>;

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

@@ -2,7 +2,3 @@ export { fetchEnsAddress, type FetchEnsAddressArgs, type FetchEnsAddressResult,
 export { fetchEnsAvatar, type FetchEnsAvatarArgs, type FetchEnsAvatarResult, } from './fetchEnsAvatar';
 export { fetchEnsName, type FetchEnsNameArgs, type FetchEnsNameResult, } from './fetchEnsName';
 export { fetchEnsResolver, type FetchEnsResolverArgs, type FetchEnsResolverResult, } from './fetchEnsResolver';
-export { watchEnsAddress, type WatchEnsAddressCallback, } from './watchEnsAddress';
-export { type WatchEnsAvatarCallback, watchEnsAvatar } from './watchEnsAvatar';
-export { type WatchEnsNameCallback, watchEnsName } from './watchEnsName';
-export { watchEnsResolver, type WatchEnsResolverCallback, } from './watchEnsResolver';

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

@@ -1,7 +1,7 @@
-export { connect, disconnect, fetchBalance, fetchSigner, getAccount, getNetwork, signMessage, signTypedData, switchNetwork, watchAccount, watchBalance, watchNetwork, watchSigner, 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 WatchBalanceCallback, type WatchNetworkCallback, type WatchSignerCallback, } from './accounts';
+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, watchEnsAddress, watchEnsAvatar, watchEnsName, watchEnsResolver, type FetchEnsAddressArgs, type FetchEnsAddressResult, type FetchEnsAvatarArgs, type FetchEnsAvatarResult, type FetchEnsNameArgs, type FetchEnsNameResult, type FetchEnsResolverArgs, type FetchEnsResolverResult, type WatchEnsAddressCallback, type WatchEnsAvatarCallback, type WatchEnsNameCallback, type WatchEnsResolverCallback, } from './ens';
-export { fetchBlockNumber, fetchFeeData, watchBlockNumber, watchFeeData, type FetchBlockNumberResult, type FetchFeeDataArgs, type FetchFeeDataResult, type WatchBlockNumberArgs, type WatchBlockNumberCallback, type WatchFeeDataArgs, type WatchFeeDataCallback, } from './network-status';
-export { getProvider, getWebSocketProvider, watchProvider, watchWebSocketProvider, type GetProviderResult, type GetWebSocketProviderResult, type WatchProviderCallback, type WatchWebSocketProviderCallback, } from './providers';
-export { fetchToken, watchToken, type FetchTokenArgs, type FetchTokenResult, type WatchTokenCallback, } from './tokens';
+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

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

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

@@ -3,6 +3,8 @@ 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: {
@@ -11,4 +13,4 @@ export declare type FetchFeeDataResult = FeeData & {
         maxPriorityFeePerGas: string;
     };
 };
-export declare function fetchFeeData({ formatUnits: units, }?: FetchFeeDataArgs): Promise<FetchFeeDataResult>;
+export declare function fetchFeeData({ chainId, formatUnits: units, }?: FetchFeeDataArgs): Promise<FetchFeeDataResult>;

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

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

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

@@ -1,3 +1,7 @@
 import type { BaseProvider } from '@ethersproject/providers';
-export declare type GetProviderResult = BaseProvider;
-export declare function getProvider(): GetProviderResult;
+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

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

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

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

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

@@ -1,3 +1,4 @@
-import { GetProviderResult } from './getProvider';
-export declare type WatchProviderCallback = (provider: GetProviderResult) => void;
-export declare function watchProvider(callback: WatchProviderCallback): () => void;
+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

@@ -1,3 +1,4 @@
-import { GetWebSocketProviderResult } from './getWebSocketProvider';
-export declare type WatchWebSocketProviderCallback = (webSocketProvider: GetWebSocketProviderResult) => void;
-export declare function watchWebSocketProvider(callback: WatchWebSocketProviderCallback): () => void;
+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

@@ -1,7 +1,11 @@
 import { BigNumber } from 'ethers/lib/ethers';
 import { Unit } from '../../types';
 export declare type FetchTokenArgs = {
-    address?: string;
+    /** 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 = {
@@ -13,12 +17,4 @@ export declare type FetchTokenResult = {
         value: BigNumber;
     };
 };
-export declare function fetchToken({ address, formatUnits: units, }: FetchTokenArgs): Promise<{
-    address: string;
-    decimals: any;
-    symbol: any;
-    totalSupply: {
-        formatted: string;
-        value: any;
-    };
-}>;
+export declare function fetchToken({ address, chainId, formatUnits: units, }: FetchTokenArgs): Promise<FetchTokenResult>;

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

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

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

@@ -1,5 +1,7 @@
 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
@@ -12,4 +14,4 @@ export declare type WaitForTransactionArgs = {
     wait?: TransactionResponse['wait'];
 };
 export declare type WaitForTransactionResult = TransactionReceipt;
-export declare function waitForTransaction(args: WaitForTransactionArgs): Promise<WaitForTransactionResult>;
+export declare function waitForTransaction({ chainId, confirmations, hash, timeout, wait: wait_, }: WaitForTransactionArgs): Promise<WaitForTransactionResult>;

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

@@ -2,7 +2,7 @@ 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 = {
+export declare type ClientConfig<TProvider extends BaseProvider = BaseProvider, TWebSocketProvider extends WebSocketProvider = WebSocketProvider> = {
     /** Enables reconnecting to last used connector on init */
     autoConnect?: boolean;
     /**
@@ -18,7 +18,7 @@ export declare type ClientConfig = {
      */
     provider?: ((config: {
         chainId?: number;
-    }) => BaseProvider) | BaseProvider;
+    }) => TProvider) | TProvider;
     /**
      * Custom storage for data persistance
      * @default window.localStorage
@@ -27,54 +27,55 @@ export declare type ClientConfig = {
     /** WebSocket interface for connecting to network */
     webSocketProvider?: ((config: {
         chainId?: number;
-    }) => WebSocketProvider | undefined) | WebSocketProvider;
+    }) => TWebSocketProvider | undefined) | TWebSocketProvider;
 };
-export declare type Data = ConnectorData<BaseProvider>;
-export declare type State = {
+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;
+    data?: Data<TProvider>;
     error?: Error;
-    provider: BaseProvider;
+    provider: TProvider;
     status: 'connected' | 'connecting' | 'reconnecting' | 'disconnected';
-    webSocketProvider?: WebSocketProvider;
+    webSocketProvider?: TWebSocketProvider;
 };
-export declare class Client {
+export declare class Client<TProvider extends BaseProvider = BaseProvider, TWebSocketProvider extends WebSocketProvider = WebSocketProvider> {
     #private;
-    config: Partial<ClientConfig>;
+    config: Partial<ClientConfig<TProvider, TWebSocketProvider>>;
     storage: WagmiStorage;
-    store: Mutate<StoreApi<State>, [
+    store: Mutate<StoreApi<State<TProvider, TWebSocketProvider>>, [
         [
             'zustand/subscribeWithSelector',
             never
         ],
         [
             'zustand/persist',
-            Partial<State>
+            Partial<State<TProvider, TWebSocketProvider>>
         ]
     ]>;
-    constructor({ autoConnect, connectors, provider, storage, webSocketProvider, }?: ClientConfig);
+    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 | undefined;
+    get data(): Data<TProvider> | undefined;
     get error(): Error | undefined;
-    get provider(): BaseProvider;
+    get provider(): TProvider;
     get status(): "connecting" | "connected" | "reconnecting" | "disconnected";
     get subscribe(): {
-        (listener: (selectedState: State, previousSelectedState: State) => void): () => void;
-        <U>(selector: (state: State) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
+        (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(): WebSocketProvider | undefined;
-    setState(updater: State | ((state: State) => State)): 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 | undefined>;
+    autoConnect(): Promise<Data<TProvider> | undefined>;
     setLastUsedConnector(lastUsedConnector?: string | null): void;
 }
-export declare let client: Client;
-export declare function createClient(config?: ClientConfig): Client;
+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

@@ -34,7 +34,7 @@ export declare abstract class Connector<Provider = any, Options = any> extends E
         chains?: Chain[];
         options: Options;
     });
-    abstract connect(): Promise<ConnectorData>;
+    abstract connect(): Promise<Required<ConnectorData>>;
     abstract disconnect(): Promise<void>;
     abstract getAccount(): Promise<string>;
     abstract getChainId(): Promise<number>;
@@ -50,5 +50,7 @@ export declare abstract class Connector<Provider = any, Options = any> extends E
     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 getRpcUrls(chain: Chain): string[];
     protected isChainUnsupported(chainId: number): boolean;
 }

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

@@ -4,7 +4,16 @@ import type { CoinbaseWalletSDKOptions } from '@coinbase/wallet-sdk/dist/Coinbas
 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;

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

@@ -25,20 +25,12 @@ export declare class InjectedConnector extends Connector<Window['ethereum'], Inj
             id: number;
             unsupported: boolean;
         };
-        provider: InjectedProviders & {
-            on?: ((...args: any[]) => void) | undefined;
-            removeListener?: ((...args: any[]) => void) | undefined;
-            request<T = any>(args: RequestArguments): Promise<T>;
-        };
+        provider: Ethereum;
     }>;
     disconnect(): Promise<void>;
     getAccount(): Promise<string>;
     getChainId(): Promise<number>;
-    getProvider(): Promise<(InjectedProviders & {
-        on?: ((...args: any[]) => void) | undefined;
-        removeListener?: ((...args: any[]) => void) | undefined;
-        request<T = any>(args: RequestArguments): Promise<T>;
-    }) | undefined>;
+    getProvider(): Promise<Ethereum | undefined>;
     getSigner(): Promise<providers.JsonRpcSigner>;
     isAuthorized(): Promise<boolean>;
     switchChain(chainId: number): Promise<Chain>;

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

@@ -7,7 +7,7 @@ export declare class MockConnector extends Connector<MockProvider, MockProviderO
     readonly name = "Mock";
     readonly ready = true;
     constructor(config: {
-        chains: Chain[];
+        chains?: Chain[];
         options: MockProviderOptions;
     });
     connect(): Promise<{

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

@@ -4,8 +4,10 @@ import type { Listener } from '@ethersproject/providers';
 import { providers } from 'ethers';
 export declare type MockProviderOptions = {
     flags?: {
+        isAuthorized?: boolean;
         failConnect?: boolean;
         failSwitchChain?: boolean;
+        noSwitchChain?: boolean;
     };
     network?: number | string;
     signer: Signer;

package/dist/declarations/src/constants/abis.d.ts

@@ -0,0 +1,2 @@
+export declare const erc20ABI: string[];
+export declare const erc721ABI: string[];

package/dist/declarations/src/constants/blockExplorers.d.ts

@@ -0,0 +1,9 @@
+import { ChainName } from './chains';
+export declare type BlockExplorerName = 'etherscan';
+export declare type BlockExplorer = {
+    name: string;
+    url: string;
+};
+declare type EtherscanChains = Extract<ChainName, 'mainnet' | 'ropsten' | 'rinkeby' | 'goerli' | 'kovan' | 'optimism' | 'optimismKovan' | 'polygon' | 'polygonMumbai' | 'arbitrum' | 'arbitrumRinkeby'>;
+export declare const etherscanBlockExplorers: Record<EtherscanChains, BlockExplorer>;
+export {};

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

@@ -1,10 +1,21 @@
 import { Chain } from '../types';
-declare type ChainName = 'arbitrumOne' | 'arbitrumRinkeby' | 'avalanche' | 'avalancheFuji' | 'goerli' | 'hardhat' | 'kovan' | 'localhost' | 'mainnet' | 'optimism' | 'optimismKovan' | 'polygonMainnet' | 'polygonTestnetMumbai' | 'rinkeby' | 'ropsten';
-/**
- * Data from Chainlist
- * @see https://chainlist.org
- */
+export declare type ChainName = 'arbitrum' | 'arbitrumRinkeby' | 'goerli' | 'hardhat' | 'kovan' | 'localhost' | 'mainnet' | 'optimism' | 'optimismKovan' | 'polygon' | 'polygonMumbai' | 'rinkeby' | 'ropsten';
+export declare const chainId: {
+    readonly mainnet: 1;
+    readonly ropsten: 3;
+    readonly rinkeby: 4;
+    readonly goerli: 5;
+    readonly kovan: 42;
+    readonly optimism: 10;
+    readonly optimismKovan: 69;
+    readonly polygon: 137;
+    readonly polygonMumbai: 80001;
+    readonly arbitrum: 42161;
+    readonly arbitrumRinkeby: 421611;
+    readonly localhost: 1337;
+    readonly hardhat: 31337;
+};
 export declare const chain: Record<ChainName, Chain>;
 export declare const allChains: Chain[];
 export declare const defaultChains: Chain[];
-export {};
+export declare const defaultL2Chains: Chain[];

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

@@ -1,3 +1,7 @@
-export { erc1155ABI, erc20ABI, erc721ABI } from './abis';
-export { chain, allChains, defaultChains } from './chains';
+export { erc20ABI, erc721ABI } from './abis';
+export { etherscanBlockExplorers } from './blockExplorers';
+export type { BlockExplorer, BlockExplorerName } from './blockExplorers';
+export { chain, chainId, allChains, defaultChains, defaultL2Chains, } from './chains';
+export { alchemyRpcUrls, infuraRpcUrls } from './rpcs';
+export type { RpcProviderName } from './rpcs';
 export { units } from './units';

package/dist/declarations/src/constants/rpcs.d.ts

@@ -0,0 +1,9 @@
+import { ChainName } from './chains';
+export declare const defaultAlchemyId = "_gg7wSSi0KMBsdKnGVfHDueq6xMB9EkC";
+export declare const defaultInfuraId = "84842078b09946638c03157f83405213";
+export declare type RpcProviderName = 'alchemy' | 'infura';
+declare type AlchemyChains = Extract<ChainName, 'mainnet' | 'ropsten' | 'rinkeby' | 'goerli' | 'kovan' | 'optimism' | 'optimismKovan' | 'polygon' | 'polygonMumbai' | 'arbitrum' | 'arbitrumRinkeby'>;
+export declare const alchemyRpcUrls: Record<AlchemyChains, string>;
+declare type InfuraChains = Extract<ChainName, 'mainnet' | 'ropsten' | 'rinkeby' | 'goerli' | 'kovan' | 'optimism' | 'optimismKovan' | 'polygon' | 'polygonMumbai' | 'arbitrum' | 'arbitrumRinkeby'>;
+export declare const infuraRpcUrls: Record<InfuraChains, string>;
+export {};

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

@@ -1,9 +1,12 @@
-export { connect, disconnect, fetchBalance, fetchBlockNumber, fetchEnsAddress, fetchEnsAvatar, fetchEnsName, fetchEnsResolver, fetchFeeData, fetchSigner, fetchToken, getAccount, getContract, getNetwork, getProvider, getWebSocketProvider, readContract, sendTransaction, signMessage, signTypedData, switchNetwork, waitForTransaction, watchAccount, watchBalance, watchBlockNumber, watchContractEvent, watchEnsAddress, watchEnsAvatar, watchEnsName, watchEnsResolver, watchFeeData, watchNetwork, watchReadContract, watchSigner, watchToken, writeContract, } from './actions';
-export type { ConnectResult, FetchBalanceArgs, FetchBalanceResult, FetchBlockNumberResult, FetchEnsAddressArgs, FetchEnsAddressResult, FetchEnsAvatarArgs, FetchEnsAvatarResult, FetchEnsNameArgs, FetchEnsNameResult, FetchEnsResolverArgs, FetchEnsResolverResult, FetchFeeDataArgs, FetchFeeDataResult, FetchSignerResult, FetchTokenArgs, FetchTokenResult, GetAccountResult, GetContractArgs, GetNetworkResult, ReadContractArgs, ReadContractConfig, ReadContractResult, SendTransactionArgs, SendTransactionResult, SignMessageArgs, SignMessageResult, SignTypedDataArgs, SignTypedDataResult, SwitchNetworkArgs, SwitchNetworkResult, WaitForTransactionArgs, WaitForTransactionResult, WatchAccountCallback, WatchBalanceCallback, WatchBlockNumberArgs, WatchBlockNumberCallback, WatchEnsAddressCallback, WatchEnsAvatarCallback, WatchEnsNameCallback, WatchEnsResolverCallback, WatchFeeDataArgs, WatchFeeDataCallback, WatchNetworkCallback, WatchReadContractArgs, WatchReadContractConfig, WatchReadContractResult, WatchSignerCallback, WatchTokenCallback, WriteContractArgs, WriteContractConfig, WriteContractResult, } from './actions';
-export { createClient, createClient as createWagmiClient, Client, Client as WagmiClient, type ClientConfig, type ClientConfig as WagmiClientConfig, } from './client';
-export { Connector, InjectedConnector, type ConnectorData, type ConnectorEvents, } from './connectors';
-export { allChains, chain, defaultChains, erc1155ABI, erc20ABI, erc721ABI, units, } from './constants';
+export { connect, disconnect, fetchBalance, fetchBlockNumber, fetchEnsAddress, fetchEnsAvatar, fetchEnsName, fetchEnsResolver, fetchFeeData, fetchSigner, fetchToken, getAccount, getContract, getNetwork, getProvider, getWebSocketProvider, readContract, sendTransaction, signMessage, signTypedData, switchNetwork, waitForTransaction, watchAccount, watchBlockNumber, watchContractEvent, watchNetwork, watchProvider, watchReadContract, watchSigner, watchWebSocketProvider, writeContract, } from './actions';
+export type { ConnectArgs, ConnectResult, FetchBalanceArgs, FetchBalanceResult, FetchBlockNumberArgs, FetchBlockNumberResult, FetchEnsAddressArgs, FetchEnsAddressResult, FetchEnsAvatarArgs, FetchEnsAvatarResult, FetchEnsNameArgs, FetchEnsNameResult, FetchEnsResolverArgs, FetchEnsResolverResult, FetchFeeDataArgs, FetchFeeDataResult, FetchSignerResult, FetchTokenArgs, FetchTokenResult, GetAccountResult, GetContractArgs, GetNetworkResult, GetProviderArgs, GetProviderResult, GetWebSocketProviderArgs, GetWebSocketProviderResult, ReadContractArgs, ReadContractConfig, ReadContractResult, SendTransactionArgs, SendTransactionResult, SignMessageArgs, SignMessageResult, SignTypedDataArgs, SignTypedDataResult, SwitchNetworkArgs, SwitchNetworkResult, WaitForTransactionArgs, WaitForTransactionResult, WatchAccountCallback, WatchBlockNumberArgs, WatchBlockNumberCallback, WatchNetworkCallback, WatchReadContractArgs, WatchReadContractConfig, WatchReadContractResult, WatchSignerCallback, WriteContractArgs, WriteContractConfig, WriteContractResult, } from './actions';
+export { createClient, createClient as createWagmiClient, Client, Client as WagmiClient, } from './client';
+export type { ClientConfig, ClientConfig as WagmiClientConfig } from './client';
+export { Connector, InjectedConnector } from './connectors';
+export type { ConnectorData, ConnectorEvents } from './connectors';
+export { alchemyRpcUrls, allChains, chain, chainId, defaultChains, defaultL2Chains, erc20ABI, erc721ABI, etherscanBlockExplorers, infuraRpcUrls, units, } from './constants';
 export { AddChainError, ChainNotConfiguredError, ConnectorAlreadyConnectedError, ConnectorNotFoundError, SwitchChainError, SwitchChainNotSupportedError, UserRejectedRequestError, } from './errors';
-export { createStorage, createStorage as createWagmiStorage, noopStorage, type WagmiStorage as Storage, type WagmiStorage, } from './storage';
+export { createStorage, createStorage as createWagmiStorage, noopStorage, } from './storage';
+export type { WagmiStorage as Storage, WagmiStorage } from './storage';
 export type { Chain, Unit } from './types';
 export { normalizeChainId } from './utils';

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

@@ -1,14 +1,85 @@
-import { units } from '../constants';
-import './declarations';
+import { BlockExplorer, BlockExplorerName, RpcProviderName, units } from '../constants';
 export declare type Chain = {
     id: number;
     name: AddEthereumChainParameter['chainName'];
     nativeCurrency?: AddEthereumChainParameter['nativeCurrency'];
-    rpcUrls: AddEthereumChainParameter['rpcUrls'];
+    rpcUrls: {
+        [key in RpcProviderName]?: string;
+    } & {
+        [key: string]: string;
+        default: string;
+    };
     blockExplorers?: {
-        name: string;
-        url: string;
-    }[];
+        [key in BlockExplorerName]: BlockExplorer;
+    } & {
+        [key: string]: BlockExplorer;
+        default: BlockExplorer;
+    };
     testnet?: boolean;
 };
 export declare type Unit = typeof units[number];
+declare global {
+    type AddEthereumChainParameter = {
+        chainId: string;
+        chainName: string;
+        nativeCurrency?: {
+            name: string;
+            symbol: string;
+            decimals: number;
+        };
+        rpcUrls: string[];
+        blockExplorerUrls?: string[];
+        iconUrls?: string[];
+    };
+    type WatchAssetParams = {
+        type: 'ERC20';
+        options: {
+            address: string;
+            decimals: number;
+            image?: string;
+            symbol: string;
+        };
+    };
+    type RequestArguments = {
+        method: 'eth_accounts';
+    } | {
+        method: 'eth_chainId';
+    } | {
+        method: 'eth_requestAccounts';
+    } | {
+        method: 'personal_sign';
+        params: [string, string];
+    } | {
+        method: 'wallet_addEthereumChain';
+        params: AddEthereumChainParameter[];
+    } | {
+        method: 'wallet_switchEthereumChain';
+        params: [{
+            chainId: string;
+        }];
+    } | {
+        method: 'wallet_watchAsset';
+        params: WatchAssetParams;
+    };
+    type InjectedProviders = {
+        isBraveWallet?: true;
+        isCoinbaseWallet?: true;
+        isFrame?: true;
+        isMetaMask?: true;
+        isTally?: true;
+    };
+    interface Ethereum extends InjectedProviders {
+        on?: (...args: any[]) => void;
+        removeListener?: (...args: any[]) => void;
+        request<T = any>(args: RequestArguments): Promise<T>;
+        providers?: Ethereum[];
+    }
+    interface Window {
+        ethereum?: Ethereum;
+    }
+    interface ProviderRpcError extends Error {
+        code: 4001 | 4902;
+        data?: unknown;
+        message: string;
+    }
+}

package/dist/declarations/src/utils/getInjectedName.d.ts

@@ -1 +1 @@
-export declare function getInjectedName(ethereum?: Window['ethereum']): "Coinbase Wallet" | "Injected" | "MetaMask" | "Frame" | "Tally";
+export declare function getInjectedName(ethereum?: Window['ethereum']): string;