@wagmi/core 0.2.0-next.1 → 0.2.0-next.10

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

@@ -1,8 +1,8 @@
-import type { BaseProvider, WebSocketProvider } from '@ethersproject/providers';
+import { 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,52 +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, 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(): "connected" | "connecting" | "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

@@ -12,6 +12,10 @@ export declare type ConnectorData<Provider = any> = {
 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;
 }
@@ -30,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>;
@@ -46,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): string[];
+    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/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/keys.d.ts

@@ -0,0 +1,2 @@
+export declare const defaultAlchemyId = "_gg7wSSi0KMBsdKnGVfHDueq6xMB9EkC";
+export declare const defaultInfuraId = "84842078b09946638c03157f83405213";

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

@@ -0,0 +1,7 @@
+import { ChainName } from './chains';
+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 type { ConnectArgs, 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, } 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,19 @@
-import { units } from '../constants';
+import { BlockExplorer, BlockExplorerName, RpcProviderName, units } from '../constants';
 import './declarations';
 export declare type Chain = {
     id: number;
     name: AddEthereumChainParameter['chainName'];
     nativeCurrency?: AddEthereumChainParameter['nativeCurrency'];
-    rpcUrls: AddEthereumChainParameter['rpcUrls'];
+    rpcUrls: {
+        [key in RpcProviderName]?: string;
+    } & {
+        default: string | string[];
+    };
     blockExplorers?: {
-        name: string;
-        url: string;
-    }[];
+        [key in BlockExplorerName]?: BlockExplorer;
+    } & {
+        default: BlockExplorer | BlockExplorer[];
+    };
     testnet?: boolean;
 };
 export declare type Unit = typeof units[number];