@wagmi/core 0.2.5 → 0.3.2

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

@@ -1,16 +1,16 @@
-import { providers } from 'ethers';
 import { Client } from '../../client';
 import { Connector, ConnectorData } from '../../connectors';
+import { Provider } from '../../types';
 export declare type ConnectArgs = {
     /** Connector to connect */
     connector: Connector;
 };
-declare type Data<TProvider extends providers.BaseProvider = providers.BaseProvider> = Required<ConnectorData<TProvider>>;
-export declare type ConnectResult<TProvider extends providers.BaseProvider = providers.BaseProvider> = {
+declare type Data<TProvider extends Provider = Provider> = Required<ConnectorData<TProvider>>;
+export declare type ConnectResult<TProvider extends Provider = Provider> = {
     account: Data<TProvider>['account'];
     chain: Data<TProvider>['chain'];
     connector: Client<TProvider>['connector'];
     provider: Data<TProvider>['provider'];
 };
-export declare function connect<TProvider extends providers.BaseProvider>({ connector, }: ConnectArgs): Promise<ConnectResult<TProvider>>;
+export declare function connect<TProvider extends Provider = Provider>({ connector, }: ConnectArgs): Promise<ConnectResult<TProvider>>;
 export {};

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

@@ -1,7 +1,7 @@
-import { providers } from 'ethers';
 import { Client, Data } from '../../client';
-export declare type GetAccountResult<TProvider extends providers.BaseProvider = providers.BaseProvider> = {
+import { Provider } from '../../types';
+export declare type GetAccountResult<TProvider extends Provider = Provider> = {
     address?: Data<TProvider>['account'];
     connector?: Client<TProvider>['connector'];
 };
-export declare function getAccount<TProvider extends providers.BaseProvider>(): GetAccountResult<TProvider>;
+export declare function getAccount<TProvider extends Provider>(): GetAccountResult<TProvider>;

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

@@ -1,13 +1,22 @@
-import type { providers } from 'ethers';
-declare type SignTypedData = Parameters<providers.JsonRpcSigner['_signTypedData']>;
+import { BigNumberish, BytesLike } from 'ethers';
+export interface TypedDataDomain {
+    name?: string;
+    version?: string;
+    chainId?: BigNumberish;
+    verifyingContract?: string;
+    salt?: BytesLike;
+}
+export interface TypedDataField {
+    name: string;
+    type: string;
+}
 export declare type SignTypedDataArgs = {
     /** Domain or domain signature for origin or contract */
-    domain: SignTypedData[0];
+    domain: TypedDataDomain;
     /** Named list of all type definitions */
-    types: SignTypedData[1];
+    types: Record<string, Array<TypedDataField>>;
     /** Data to sign */
-    value: SignTypedData[2];
+    value: Record<string, any>;
 };
 export declare type SignTypedDataResult = string;
 export declare function signTypedData(args: SignTypedDataArgs): Promise<SignTypedDataResult>;
-export {};

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

@@ -1,4 +1,4 @@
-import { providers } from 'ethers';
+import { Provider } from '../../types';
 import { GetAccountResult } from './getAccount';
-export declare type WatchAccountCallback<TProvider extends providers.BaseProvider = providers.BaseProvider> = (data: GetAccountResult<TProvider>) => void;
-export declare function watchAccount<TProvider extends providers.BaseProvider>(callback: WatchAccountCallback<TProvider>): () => void;
+export declare type WatchAccountCallback<TProvider extends Provider = Provider> = (data: GetAccountResult<TProvider>) => void;
+export declare function watchAccount<TProvider extends Provider>(callback: WatchAccountCallback<TProvider>): () => void;

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

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

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

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

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

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

@@ -1,4 +1,4 @@
-import { providers } from 'ethers';
+import { WebSocketProvider } from '../../types';
 import { GetWebSocketProviderArgs, GetWebSocketProviderResult } from './getWebSocketProvider';
-export declare type WatchWebSocketProviderCallback<TWebSocketProvider extends providers.WebSocketProvider = providers.WebSocketProvider> = (webSocketProvider: GetWebSocketProviderResult<TWebSocketProvider>) => void;
-export declare function watchWebSocketProvider<TWebSocketProvider extends providers.WebSocketProvider = providers.WebSocketProvider>(args: GetWebSocketProviderArgs, callback: WatchWebSocketProviderCallback<TWebSocketProvider>): () => void;
+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/chains/configureChains.d.ts

@@ -0,0 +1,20 @@
+import { providers } from 'ethers';
+import { Chain, ChainProvider, Provider, WebSocketProvider } from '../types';
+export declare type ConfigureChainsConfig = {
+    stallTimeout?: number;
+} & ({
+    targetQuorum?: number;
+    minQuorum?: never;
+} | {
+    targetQuorum: number;
+    minQuorum?: number;
+});
+export declare function configureChains<TProvider extends Provider = Provider, TWebSocketProvider extends WebSocketProvider = WebSocketProvider, TChain extends Chain = Chain>(defaultChains: TChain[], providers: ChainProvider<TProvider, TWebSocketProvider, TChain>[], { minQuorum, targetQuorum, stallTimeout }?: ConfigureChainsConfig): {
+    readonly chains: TChain[];
+    readonly provider: ({ chainId }: {
+        chainId?: number | undefined;
+    }) => TProvider | providers.FallbackProvider;
+    readonly webSocketProvider: ({ chainId }: {
+        chainId?: number | undefined;
+    }) => TWebSocketProvider | undefined;
+};

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

@@ -0,0 +1,2 @@
+export { configureChains } from './configureChains';
+export type { ConfigureChainsConfig } from './configureChains';

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

@@ -1,8 +1,8 @@
-import { providers } from 'ethers';
 import { Mutate, StoreApi } from 'zustand/vanilla';
 import { Connector, ConnectorData } from './connectors';
-import { WagmiStorage } from './storage';
-export declare type ClientConfig<TProvider extends providers.BaseProvider = providers.BaseProvider, TWebSocketProvider extends providers.WebSocketProvider = providers.WebSocketProvider> = {
+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;
     /**
@@ -23,14 +23,14 @@ export declare type ClientConfig<TProvider extends providers.BaseProvider = prov
      * Custom storage for data persistance
      * @default window.localStorage
      */
-    storage?: WagmiStorage;
+    storage?: ClientStorage;
     /** WebSocket interface for connecting to network */
     webSocketProvider?: ((config: {
         chainId?: number;
     }) => TWebSocketProvider | undefined) | TWebSocketProvider;
 };
-export declare type Data<TProvider extends providers.BaseProvider> = ConnectorData<TProvider>;
-export declare type State<TProvider extends providers.BaseProvider, TWebSocketProvider extends providers.WebSocketProvider = providers.WebSocketProvider> = {
+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[];
@@ -40,10 +40,10 @@ export declare type State<TProvider extends providers.BaseProvider, TWebSocketPr
     status: 'connected' | 'connecting' | 'reconnecting' | 'disconnected';
     webSocketProvider?: TWebSocketProvider;
 };
-export declare class Client<TProvider extends providers.BaseProvider = providers.BaseProvider, TWebSocketProvider extends providers.WebSocketProvider = providers.WebSocketProvider> {
+export declare class Client<TProvider extends Provider = Provider, TWebSocketProvider extends WebSocketProvider = WebSocketProvider> {
     #private;
     config: Partial<ClientConfig<TProvider, TWebSocketProvider>>;
-    storage: WagmiStorage;
+    storage: ClientStorage;
     store: Mutate<StoreApi<State<TProvider, TWebSocketProvider>>, [
         [
             'zustand/subscribeWithSelector',
@@ -54,7 +54,7 @@ export declare class Client<TProvider extends providers.BaseProvider = providers
             Partial<State<TProvider, TWebSocketProvider>>
         ]
     ]>;
-    constructor(config?: ClientConfig<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;
@@ -76,6 +76,6 @@ export declare class Client<TProvider extends providers.BaseProvider = providers
     autoConnect(): Promise<Data<TProvider> | undefined>;
     setLastUsedConnector(lastUsedConnector?: string | null): void;
 }
-export declare let client: Client<providers.BaseProvider, providers.WebSocketProvider>;
-export declare function createClient<TProvider extends providers.BaseProvider = providers.BaseProvider, TWebSocketProvider extends providers.WebSocketProvider = providers.WebSocketProvider>(config?: ClientConfig<TProvider, TWebSocketProvider>): Client<TProvider, TWebSocketProvider>;
-export declare function getClient<TProvider extends providers.BaseProvider = providers.BaseProvider, TWebSocketProvider extends providers.WebSocketProvider = providers.WebSocketProvider>(): Client<TProvider, TWebSocketProvider>;
+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/injected.d.ts

@@ -17,7 +17,7 @@ export declare class InjectedConnector extends Connector<Window['ethereum'], Inj
     readonly id: string;
     readonly name: string;
     readonly ready: boolean;
-    constructor(config?: {
+    constructor({ chains, options, }?: {
         chains?: Chain[];
         options?: InjectedConnectorOptions;
     });

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

@@ -5,7 +5,7 @@ export declare class MetaMaskConnector extends InjectedConnector {
     #private;
     readonly id = "metaMask";
     readonly ready: boolean;
-    constructor(config?: {
+    constructor({ chains, options, }?: {
         chains?: Chain[];
         options?: MetaMaskConnectorOptions;
     });

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

@@ -2,6 +2,6 @@ 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 { alchemyRpcUrls, defaultAlchemyId, infuraRpcUrls, defaultInfuraId, } from './rpcs';
 export type { RpcProviderName } from './rpcs';
 export { units } from './units';

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

@@ -1,3 +1,43 @@
+/**
+ * Error subclass implementing JSON RPC 2.0 errors and Ethereum RPC errors per EIP-1474.
+ * @see https://eips.ethereum.org/EIPS/eip-1474
+ */
+export declare class RpcError<T = undefined> extends Error {
+    readonly code: number;
+    readonly data?: T;
+    readonly internal?: unknown;
+    constructor(
+    /** Number error code */
+    code: number, 
+    /** Human-readable string */
+    message: string, 
+    /** Low-level error */
+    internal?: unknown, 
+    /** Other useful information about error */
+    data?: T);
+}
+/**
+ * Error subclass implementing Ethereum Provider errors per EIP-1193.
+ * @see https://eips.ethereum.org/EIPS/eip-1193
+ */
+export declare class ProviderRpcError<T = undefined> extends RpcError<T> {
+    /**
+     * Create an Ethereum Provider JSON-RPC error.
+     * `code` must be an integer in the 1000 <= 4999 range.
+     */
+    constructor(
+    /**
+     * Number error code
+     * @see https://eips.ethereum.org/EIPS/eip-1193#error-standards
+     */
+    code: 4001 | 4100 | 4200 | 4900 | 4901 | 4902, 
+    /** Human-readable string */
+    message: string, 
+    /** Low-level error */
+    internal?: unknown, 
+    /** Other useful information about error */
+    data?: T);
+}
 export declare class AddChainError extends Error {
     name: string;
     message: string;
@@ -14,15 +54,19 @@ export declare class ConnectorNotFoundError extends Error {
     name: string;
     message: string;
 }
-export declare class SwitchChainError extends Error {
+export declare class SwitchChainError extends ProviderRpcError {
     name: string;
-    message: string;
+    constructor(error: unknown);
 }
 export declare class SwitchChainNotSupportedError extends Error {
     name: string;
     message: string;
 }
-export declare class UserRejectedRequestError extends Error {
+export declare class UserRejectedRequestError extends ProviderRpcError {
     name: string;
-    message: string;
+    constructor(error: unknown);
+}
+export declare class ResourceUnavailableError extends RpcError {
+    name: string;
+    constructor(error: unknown);
 }

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

@@ -1,12 +1,14 @@
 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 { configureChains } from './chains';
+export type { ConfigureChainsConfig } from './chains';
+export { createClient, Client } from './client';
+export type { ClientConfig } 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, } from './storage';
-export type { WagmiStorage as Storage, WagmiStorage } from './storage';
-export type { Chain, Unit } from './types';
+export { AddChainError, ChainNotConfiguredError, ConnectorAlreadyConnectedError, ConnectorNotFoundError, ProviderRpcError, ResourceUnavailableError, RpcError, SwitchChainError, SwitchChainNotSupportedError, UserRejectedRequestError, } from './errors';
+export { createStorage, noopStorage } from './storage';
+export type { ClientStorage as Storage } from './storage';
+export type { Chain, ChainProvider, FallbackProviderConfig, ProviderWithFallbackConfig, Provider, Unit, WebSocketProvider, } from './types';
 export { normalizeChainId } from './utils';

package/dist/declarations/src/providers/alchemy.d.ts

@@ -0,0 +1,7 @@
+import { providers } from 'ethers';
+import { ChainProvider, FallbackProviderConfig } from '../types';
+export declare type AlchemyProviderConfig = FallbackProviderConfig & {
+    alchemyId?: string;
+    pollingInterval?: number;
+};
+export declare function alchemyProvider({ alchemyId, pollingInterval, priority, stallTimeout, weight, }?: AlchemyProviderConfig): ChainProvider<providers.AlchemyProvider, providers.AlchemyWebSocketProvider>;

package/dist/declarations/src/providers/infura.d.ts

@@ -0,0 +1,7 @@
+import { providers } from 'ethers';
+import { ChainProvider, FallbackProviderConfig } from '../types';
+export declare type InfuraProviderConfig = FallbackProviderConfig & {
+    infuraId?: string;
+    pollingInterval?: number;
+};
+export declare function infuraProvider({ infuraId, pollingInterval, priority, stallTimeout, weight, }?: InfuraProviderConfig): ChainProvider<providers.InfuraProvider, providers.InfuraWebSocketProvider>;

package/dist/declarations/src/providers/jsonRpc.d.ts

@@ -0,0 +1,11 @@
+import { providers } from 'ethers';
+import { Chain, ChainProvider, FallbackProviderConfig } from '../types';
+export declare type JsonRpcProviderConfig = FallbackProviderConfig & {
+    pollingInterval?: number;
+    rpc: (chain: Chain) => {
+        http: string;
+        webSocket?: string;
+    } | null;
+    static?: boolean;
+};
+export declare function jsonRpcProvider({ pollingInterval, priority, rpc, stallTimeout, static: static_, weight, }: JsonRpcProviderConfig): ChainProvider<providers.JsonRpcProvider, providers.WebSocketProvider>;

package/dist/declarations/src/providers/public.d.ts

@@ -0,0 +1,6 @@
+import { providers } from 'ethers';
+import { ChainProvider, FallbackProviderConfig } from '../types';
+export declare type PublicProviderConfig = FallbackProviderConfig & {
+    pollingInterval?: number;
+};
+export declare function publicProvider({ pollingInterval, priority, stallTimeout, weight, }?: PublicProviderConfig): ChainProvider<providers.StaticJsonRpcProvider>;

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

@@ -1,5 +1,5 @@
 declare type BaseStorage = Pick<Storage, 'getItem' | 'setItem' | 'removeItem'>;
-export declare type WagmiStorage = {
+export declare type ClientStorage = {
     getItem: <T>(key: string, defaultState?: T | null) => T | null;
     setItem: <T>(key: string, value: T | null) => void;
     removeItem: (key: string) => void;
@@ -8,5 +8,5 @@ export declare const noopStorage: BaseStorage;
 export declare function createStorage({ storage, key: prefix, }: {
     storage: BaseStorage;
     key?: string;
-}): WagmiStorage;
+}): ClientStorage;
 export {};

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

@@ -1,7 +1,9 @@
+import { providers } from 'ethers';
 import { BlockExplorer, BlockExplorerName, RpcProviderName, units } from '../constants';
 export declare type Chain = {
     id: number;
     name: AddEthereumChainParameter['chainName'];
+    network: string;
     nativeCurrency?: AddEthereumChainParameter['nativeCurrency'];
     rpcUrls: {
         [key in RpcProviderName]?: string;
@@ -17,26 +19,43 @@ export declare type Chain = {
     };
     testnet?: boolean;
 };
+export declare type ChainProvider<TProvider extends Provider = Provider, TWebSocketProvider extends WebSocketProvider = WebSocketProvider, TChain extends Chain = Chain> = (chain: TChain) => {
+    chain: TChain;
+    provider: () => ProviderWithFallbackConfig<TProvider>;
+    webSocketProvider?: () => TWebSocketProvider;
+} | null;
+export declare type FallbackProviderConfig = Omit<providers.FallbackProviderConfig, 'provider'>;
+export declare type ProviderWithFallbackConfig<TProvider extends Provider = Provider> = TProvider & FallbackProviderConfig;
+export declare type Provider = providers.BaseProvider;
+export declare type WebSocketProvider = providers.WebSocketProvider;
 export declare type Unit = typeof units[number];
 declare global {
     type AddEthereumChainParameter = {
+        /** A 0x-prefixed hexadecimal string */
         chainId: string;
         chainName: string;
         nativeCurrency?: {
             name: string;
+            /** 2-6 characters long */
             symbol: string;
             decimals: number;
         };
         rpcUrls: string[];
         blockExplorerUrls?: string[];
+        /** Currently ignored. */
         iconUrls?: string[];
     };
     type WatchAssetParams = {
+        /** In the future, other standards will be supported */
         type: 'ERC20';
         options: {
+            /** Address of token contract */
             address: string;
+            /** Number of token decimals */
             decimals: number;
+            /** String url of token logo */
             image?: string;
+            /** A ticker symbol or shorthand, up to 5 characters */
             symbol: string;
         };
     };
@@ -69,6 +88,18 @@ declare global {
         on?: (...args: any[]) => void;
         removeListener?: (...args: any[]) => void;
         providers?: Ethereum[];
+        /**
+         * EIP-747: Add wallet_watchAsset to Provider
+         * https://eips.ethereum.org/EIPS/eip-747
+         */
+        request(args: {
+            method: 'wallet_watchAsset';
+            params: WatchAssetParams;
+        }): Promise<boolean>;
+        /**
+         * EIP-1193: Ethereum Provider JavaScript API
+         * https://eips.ethereum.org/EIPS/eip-1193
+         */
         request(args: {
             method: 'eth_accounts';
         }): Promise<string[]>;
@@ -78,34 +109,33 @@ declare global {
         request(args: {
             method: 'eth_requestAccounts';
         }): Promise<string[]>;
+        /**
+         * EIP-1474: Remote procedure call specification
+         * https://eips.ethereum.org/EIPS/eip-1474
+         */
         request(args: {
-            method: 'personal_sign';
-            params: [string, string];
+            method: 'web3_clientVersion';
         }): Promise<string>;
+        /**
+         * EIP-3085: Wallet Add Ethereum Chain RPC Method
+         * https://eips.ethereum.org/EIPS/eip-3085
+         */
         request(args: {
             method: 'wallet_addEthereumChain';
             params: AddEthereumChainParameter[];
         }): Promise<null>;
+        /**
+         * EIP-3326: Wallet Switch Ethereum Chain RPC Method
+         * https://eips.ethereum.org/EIPS/eip-3326
+         */
         request(args: {
             method: 'wallet_switchEthereumChain';
             params: [{
                 chainId: string;
             }];
         }): Promise<null>;
-        request(args: {
-            method: 'wallet_watchAsset';
-            params: WatchAssetParams;
-        }): Promise<boolean>;
-        request(args: {
-            method: 'web3_clientVersion';
-        }): Promise<string>;
     }
     interface Window {
         ethereum?: Ethereum;
     }
-    interface ProviderRpcError extends Error {
-        code: 4001 | 4902;
-        data?: unknown;
-        message: string;
-    }
 }

package/dist/rpcs-7cfbd91c.esm.js

@@ -0,0 +1,30 @@
+const defaultAlchemyId = '_gg7wSSi0KMBsdKnGVfHDueq6xMB9EkC';
+const defaultInfuraId = '84842078b09946638c03157f83405213';
+const alchemyRpcUrls = {
+  mainnet: 'https://eth-mainnet.alchemyapi.io/v2',
+  ropsten: 'https://eth-ropsten.alchemyapi.io/v2',
+  rinkeby: 'https://eth-rinkeby.alchemyapi.io/v2',
+  goerli: 'https://eth-goerli.alchemyapi.io/v2',
+  kovan: 'https://eth-kovan.alchemyapi.io/v2',
+  optimism: 'https://opt-mainnet.g.alchemy.com/v2',
+  optimismKovan: 'https://opt-kovan.g.alchemy.com/v2',
+  polygon: 'https://polygon-mainnet.g.alchemy.com/v2',
+  polygonMumbai: 'https://polygon-mumbai.g.alchemy.com/v2',
+  arbitrum: 'https://arb-mainnet.g.alchemy.com/v2',
+  arbitrumRinkeby: 'https://arb-rinkeby.g.alchemy.com/v2'
+};
+const infuraRpcUrls = {
+  mainnet: 'https://mainnet.infura.io/v3',
+  ropsten: 'https://ropsten.infura.io/v3',
+  rinkeby: 'https://rinkeby.infura.io/v3',
+  goerli: 'https://goerli.infura.io/v3',
+  kovan: 'https://kovan.infura.io/v3',
+  optimism: 'https://optimism-mainnet.infura.io/v3',
+  optimismKovan: 'https://optimism-kovan.infura.io/v3',
+  polygon: 'https://polygon-mainnet.infura.io/v3',
+  polygonMumbai: 'https://polygon-mumbai.infura.io/v3',
+  arbitrum: 'https://arbitrum-mainnet.infura.io/v3',
+  arbitrumRinkeby: 'https://arbitrum-rinkeby.infura.io/v3'
+};
+
+export { alchemyRpcUrls as a, defaultInfuraId as b, defaultAlchemyId as d, infuraRpcUrls as i };

package/dist/rpcs-9c4eb960.cjs.dev.js

@@ -0,0 +1,35 @@
+'use strict';
+
+const defaultAlchemyId = '_gg7wSSi0KMBsdKnGVfHDueq6xMB9EkC';
+const defaultInfuraId = '84842078b09946638c03157f83405213';
+const alchemyRpcUrls = {
+  mainnet: 'https://eth-mainnet.alchemyapi.io/v2',
+  ropsten: 'https://eth-ropsten.alchemyapi.io/v2',
+  rinkeby: 'https://eth-rinkeby.alchemyapi.io/v2',
+  goerli: 'https://eth-goerli.alchemyapi.io/v2',
+  kovan: 'https://eth-kovan.alchemyapi.io/v2',
+  optimism: 'https://opt-mainnet.g.alchemy.com/v2',
+  optimismKovan: 'https://opt-kovan.g.alchemy.com/v2',
+  polygon: 'https://polygon-mainnet.g.alchemy.com/v2',
+  polygonMumbai: 'https://polygon-mumbai.g.alchemy.com/v2',
+  arbitrum: 'https://arb-mainnet.g.alchemy.com/v2',
+  arbitrumRinkeby: 'https://arb-rinkeby.g.alchemy.com/v2'
+};
+const infuraRpcUrls = {
+  mainnet: 'https://mainnet.infura.io/v3',
+  ropsten: 'https://ropsten.infura.io/v3',
+  rinkeby: 'https://rinkeby.infura.io/v3',
+  goerli: 'https://goerli.infura.io/v3',
+  kovan: 'https://kovan.infura.io/v3',
+  optimism: 'https://optimism-mainnet.infura.io/v3',
+  optimismKovan: 'https://optimism-kovan.infura.io/v3',
+  polygon: 'https://polygon-mainnet.infura.io/v3',
+  polygonMumbai: 'https://polygon-mumbai.infura.io/v3',
+  arbitrum: 'https://arbitrum-mainnet.infura.io/v3',
+  arbitrumRinkeby: 'https://arbitrum-rinkeby.infura.io/v3'
+};
+
+exports.alchemyRpcUrls = alchemyRpcUrls;
+exports.defaultAlchemyId = defaultAlchemyId;
+exports.defaultInfuraId = defaultInfuraId;
+exports.infuraRpcUrls = infuraRpcUrls;

package/dist/rpcs-b3c52116.cjs.prod.js

@@ -0,0 +1,35 @@
+'use strict';
+
+const defaultAlchemyId = '_gg7wSSi0KMBsdKnGVfHDueq6xMB9EkC';
+const defaultInfuraId = '84842078b09946638c03157f83405213';
+const alchemyRpcUrls = {
+  mainnet: 'https://eth-mainnet.alchemyapi.io/v2',
+  ropsten: 'https://eth-ropsten.alchemyapi.io/v2',
+  rinkeby: 'https://eth-rinkeby.alchemyapi.io/v2',
+  goerli: 'https://eth-goerli.alchemyapi.io/v2',
+  kovan: 'https://eth-kovan.alchemyapi.io/v2',
+  optimism: 'https://opt-mainnet.g.alchemy.com/v2',
+  optimismKovan: 'https://opt-kovan.g.alchemy.com/v2',
+  polygon: 'https://polygon-mainnet.g.alchemy.com/v2',
+  polygonMumbai: 'https://polygon-mumbai.g.alchemy.com/v2',
+  arbitrum: 'https://arb-mainnet.g.alchemy.com/v2',
+  arbitrumRinkeby: 'https://arb-rinkeby.g.alchemy.com/v2'
+};
+const infuraRpcUrls = {
+  mainnet: 'https://mainnet.infura.io/v3',
+  ropsten: 'https://ropsten.infura.io/v3',
+  rinkeby: 'https://rinkeby.infura.io/v3',
+  goerli: 'https://goerli.infura.io/v3',
+  kovan: 'https://kovan.infura.io/v3',
+  optimism: 'https://optimism-mainnet.infura.io/v3',
+  optimismKovan: 'https://optimism-kovan.infura.io/v3',
+  polygon: 'https://polygon-mainnet.infura.io/v3',
+  polygonMumbai: 'https://polygon-mumbai.infura.io/v3',
+  arbitrum: 'https://arbitrum-mainnet.infura.io/v3',
+  arbitrumRinkeby: 'https://arbitrum-rinkeby.infura.io/v3'
+};
+
+exports.alchemyRpcUrls = alchemyRpcUrls;
+exports.defaultAlchemyId = defaultAlchemyId;
+exports.defaultInfuraId = defaultInfuraId;
+exports.infuraRpcUrls = infuraRpcUrls;