@wagmi/core 0.4.0-test.2 → 0.4.2

package/dist/{client-60ee0298.esm.js → client-ffba0e25.esm.js}

@@ -1,9 +1,8 @@
-import { b as Connector, _ as _classPrivateMethodInitSpec, f as _defineProperty, g as _classPrivateFieldInitSpec, n as normalizeChainId, h as _classPrivateFieldGet, i as _classPrivateFieldSet, a as ConnectorNotFoundError, j as _classPrivateMethodGet, U as UserRejectedRequestError, R as ResourceUnavailableError, c as ChainNotConfiguredError, A as AddChainError, e as SwitchChainError } from './base-c546f171.esm.js';
-import { providers, getDefaultProvider } from 'ethers';
+import { d as Connector, _ as _classPrivateMethodInitSpec, i as _defineProperty, j as _classPrivateFieldInitSpec, n as normalizeChainId, k as _classPrivateFieldGet, l as _classPrivateFieldSet, b as ConnectorNotFoundError, m as _classPrivateMethodGet, U as UserRejectedRequestError, R as ResourceUnavailableError, e as ChainNotConfiguredError, A as AddChainError, h as SwitchChainError } from './base-e66f9622.esm.js';
 import create from 'zustand/vanilla';
 import { subscribeWithSelector, persist } from 'zustand/middleware';
+import { providers } from 'ethers';
 import { getAddress, hexValue } from 'ethers/lib/utils';
-import { a as allChains } from './chains-fa406563.esm.js';
 
 function getInjectedName(ethereum) {
   var _ethereum$providers, _getName;
@@ -17,6 +16,7 @@ function getInjectedName(ethereum) {
     if (provider.isFrame) return 'Frame';
     if (provider.isOpera) return 'Opera';
     if (provider.isTally) return 'Tally';
+    if (provider.isTokenPocket) return 'TokenPocket';
     if (provider.isTokenary) return 'Tokenary';
     if (provider.isTrust) return 'Trust Wallet';
     if (provider.isMetaMask) return 'MetaMask';
@@ -50,14 +50,6 @@ function getInjectedName(ethereum) {
   return (_getName = getName(ethereum)) !== null && _getName !== void 0 ? _getName : 'Injected';
 }
 
-const cache = new Set();
-function warn(message, id) {
-  if (!cache.has(id !== null && id !== void 0 ? id : message)) {
-    console.warn(message);
-    cache.add(message);
-  }
-}
-
 const shimKey = 'injected.shimDisconnect';
 
 var _provider = /*#__PURE__*/new WeakMap();
@@ -254,7 +246,7 @@ class InjectedConnector extends Connector {
     const id = hexValue(chainId);
 
     try {
-      var _chains$find;
+      var _this$chains$find;
 
       await provider.request({
         method: 'wallet_switchEthereumChain',
@@ -262,8 +254,7 @@ class InjectedConnector extends Connector {
           chainId: id
         }]
       });
-      const chains = [...this.chains, ...allChains];
-      return (_chains$find = chains.find(x => x.id === chainId)) !== null && _chains$find !== void 0 ? _chains$find : {
+      return (_this$chains$find = this.chains.find(x => x.id === chainId)) !== null && _this$chains$find !== void 0 ? _this$chains$find : {
         id: chainId,
         name: "Chain ".concat(id),
         network: "".concat(id),
@@ -272,18 +263,24 @@ class InjectedConnector extends Connector {
         }
       };
     } catch (error) {
+      var _data, _data$originalError;
+
       const chain = this.chains.find(x => x.id === chainId);
       if (!chain) throw new ChainNotConfiguredError(); // Indicates chain is not added to provider
 
-      if (error.code === 4902) {
+      if (error.code === 4902 || // Unwrapping for MetaMask Mobile
+      // https://github.com/MetaMask/metamask-mobile/issues/2944#issuecomment-976988719
+      (error === null || error === void 0 ? void 0 : (_data = error.data) === null || _data === void 0 ? void 0 : (_data$originalError = _data.originalError) === null || _data$originalError === void 0 ? void 0 : _data$originalError.code) === 4902) {
         try {
+          var _chain$rpcUrls$public;
+
           await provider.request({
             method: 'wallet_addEthereumChain',
             params: [{
               chainId: id,
               chainName: chain.name,
               nativeCurrency: chain.nativeCurrency,
-              rpcUrls: [chain.rpcUrls.default],
+              rpcUrls: [(_chain$rpcUrls$public = chain.rpcUrls.public) !== null && _chain$rpcUrls$public !== void 0 ? _chain$rpcUrls$public : chain.rpcUrls.default],
               blockExplorerUrls: this.getBlockExplorerUrls(chain)
             }]
           });
@@ -374,22 +371,16 @@ var _lastUsedConnector = /*#__PURE__*/new WeakMap();
 var _addEffects = /*#__PURE__*/new WeakSet();
 
 class Client {
-  constructor() {
+  constructor(_ref) {
     let {
       autoConnect = false,
       connectors = [new InjectedConnector()],
-      provider: _provider = config => {
-        try {
-          return getDefaultProvider(config.chainId);
-        } catch {
-          return getDefaultProvider();
-        }
-      },
+      provider: _provider,
       storage = createStorage({
         storage: typeof window !== 'undefined' ? window.localStorage : noopStorage
       }),
       webSocketProvider: _webSocketProvider
-    } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    } = _ref;
 
     _classPrivateMethodInitSpec(this, _addEffects);
 
@@ -424,24 +415,18 @@ class Client {
         status = data !== null && data !== void 0 && data.account ? 'reconnecting' : 'connecting';
         _chainId = data === null || data === void 0 ? void 0 : (_data$chain = data.chain) === null || _data$chain === void 0 ? void 0 : _data$chain.id; // eslint-disable-next-line no-empty
       } catch (_error) {}
-    } // Evaluate initial store values
+    } // Create store
 
 
-    const connectors_ = typeof connectors === 'function' ? connectors({
-      chainId: _chainId
-    }) : connectors;
-    const provider_ = typeof _provider === 'function' ? _provider({
-      chainId: _chainId
-    }) : _provider;
-    const webSocketProvider_ = typeof _webSocketProvider === 'function' ? _webSocketProvider({
-      chainId: _chainId
-    }) : _webSocketProvider; // Create store
-
     this.store = create(subscribeWithSelector(persist(() => ({
-      connectors: connectors_,
-      provider: provider_,
+      connectors: typeof connectors === 'function' ? connectors() : connectors,
+      provider: typeof _provider === 'function' ? _provider({
+        chainId: _chainId
+      }) : _provider,
       status,
-      webSocketProvider: webSocketProvider_
+      webSocketProvider: typeof _webSocketProvider === 'function' ? _webSocketProvider({
+        chainId: _chainId
+      }) : _webSocketProvider
     }), {
       name: storeKey,
       getStorage: () => storage,
@@ -522,7 +507,6 @@ class Client {
 
   clearState() {
     this.setState(x => ({ ...x,
-      chains: undefined,
       connector: undefined,
       data: undefined,
       error: undefined,
@@ -605,10 +589,10 @@ function _addEffects2() {
     }));
   };
 
-  this.store.subscribe(_ref => {
+  this.store.subscribe(_ref2 => {
     let {
       connector
-    } = _ref;
+    } = _ref2;
     return connector;
   }, (connector, prevConnector) => {
     var _prevConnector$off, _prevConnector$off2, _prevConnector$off3, _connector$on, _connector$on2, _connector$on3;
@@ -627,12 +611,12 @@ function _addEffects2() {
   } = this.config;
   const subscribeProvider = typeof provider === 'function';
   const subscribeWebSocketProvider = typeof webSocketProvider === 'function';
-  if (subscribeProvider || subscribeWebSocketProvider) this.store.subscribe(_ref2 => {
+  if (subscribeProvider || subscribeWebSocketProvider) this.store.subscribe(_ref3 => {
     var _data$chain2;
 
     let {
       data
-    } = _ref2;
+    } = _ref3;
     return data === null || data === void 0 ? void 0 : (_data$chain2 = data.chain) === null || _data$chain2 === void 0 ? void 0 : _data$chain2.id;
   }, chainId => {
     this.setState(x => ({ ...x,
@@ -654,8 +638,7 @@ function createClient(config) {
 }
 function getClient() {
   if (!client) {
-    warn('No client defined. Falling back to default client.');
-    return new Client();
+    throw new Error('No wagmi client found. Ensure you have set up a client: https://wagmi.sh/docs/client');
   }
 
   return client;

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

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

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

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

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

@@ -1,22 +1,24 @@
-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;
-}
+import { BytesLike } from 'ethers';
 export declare type SignTypedDataArgs = {
     /** Domain or domain signature for origin or contract */
-    domain: TypedDataDomain;
+    domain: {
+        name?: string;
+        version?: string;
+        /**
+         * Chain permitted for signing
+         * If signer is not active on this chain, it will attempt to programmatically switch
+         */
+        chainId?: string | number | bigint;
+        verifyingContract?: string;
+        salt?: BytesLike;
+    };
     /** Named list of all type definitions */
-    types: Record<string, Array<TypedDataField>>;
+    types: Record<string, Array<{
+        name: string;
+        type: string;
+    }>>;
     /** Data to sign */
     value: Record<string, any>;
 };
 export declare type SignTypedDataResult = string;
-export declare function signTypedData(args: SignTypedDataArgs): Promise<SignTypedDataResult>;
+export declare function signTypedData({ domain, types, value, }: SignTypedDataArgs): Promise<SignTypedDataResult>;

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

@@ -1,4 +1,12 @@
+import { Connector } from '../../connectors';
 import { Provider } from '../../types';
 import { GetAccountResult } from './getAccount';
 export declare type WatchAccountCallback<TProvider extends Provider = Provider> = (data: GetAccountResult<TProvider>) => void;
-export declare function watchAccount<TProvider extends Provider>(callback: WatchAccountCallback<TProvider>): () => void;
+export declare type WatchAccountConfig = {
+    selector?({ address, connector, status, }: {
+        address?: string;
+        connector?: Connector;
+        status: GetAccountResult['status'];
+    }): any;
+};
+export declare function watchAccount<TProvider extends Provider>(callback: WatchAccountCallback<TProvider>, { selector }?: WatchAccountConfig): () => void;

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

@@ -1,3 +1,10 @@
+import { Chain } from '../../types';
 import { GetNetworkResult } from './getNetwork';
 export declare type WatchNetworkCallback = (data: GetNetworkResult) => void;
-export declare function watchNetwork(callback: WatchNetworkCallback): () => void;
+export declare type WatchNetworkConfig = {
+    selector?({ chainId, chains }: {
+        chainId?: number;
+        chains?: Chain[];
+    }): any;
+};
+export declare function watchNetwork(callback: WatchNetworkCallback, { selector }?: WatchNetworkConfig): () => void;

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

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

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

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

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

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

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

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

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

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

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

@@ -1,7 +1,6 @@
-import { ReadContractArgs, ReadContractConfig, ReadContractResult } from './readContract';
-export declare type WatchReadContractArgs = ReadContractArgs;
+import { ReadContractConfig, ReadContractResult } from './readContract';
 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;
+export declare function watchReadContract(config: WatchReadContractConfig, callback: WatchReadContractResult): () => void;

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

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

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

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

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

@@ -1,5 +1,5 @@
 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 { getContract, readContract, readContracts, watchContractEvent, watchReadContract, watchReadContracts, writeContract, type GetContractArgs, type ReadContractConfig, type ReadContractResult, type ReadContractsConfig, type ReadContractsResult, type WatchReadContractConfig, type WatchReadContractResult, type WatchReadContractsConfig, type WatchReadContractsResult, type WriteContractConfig, type WriteContractResult, } from './contracts';
 export { fetchEnsAddress, fetchEnsAvatar, fetchEnsName, fetchEnsResolver, type FetchEnsAddressArgs, type FetchEnsAddressResult, type FetchEnsAvatarArgs, type FetchEnsAvatarResult, type FetchEnsNameArgs, type FetchEnsNameResult, type FetchEnsResolverArgs, type FetchEnsResolverResult, } from './ens';
 export { fetchBlockNumber, fetchFeeData, watchBlockNumber, type FetchBlockNumberArgs, type FetchBlockNumberResult, type FetchFeeDataArgs, type FetchFeeDataResult, type WatchBlockNumberArgs, type WatchBlockNumberCallback, } from './network-status';
 export { getProvider, getWebSocketProvider, watchProvider, watchWebSocketProvider, type GetProviderArgs, type GetProviderResult, type GetWebSocketProviderArgs, type GetWebSocketProviderResult, type WatchProviderCallback, type WatchWebSocketProviderCallback, } from './providers';

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

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

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

@@ -9,14 +9,9 @@ export declare type ClientConfig<TProvider extends Provider = Provider, TWebSock
      * 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: {
+    connectors?: (() => Connector[]) | Connector[];
+    /** Interface for connecting to network */
+    provider: ((config: {
         chainId?: number;
     }) => TProvider) | TProvider;
     /**
@@ -54,7 +49,7 @@ export declare class Client<TProvider extends Provider = Provider, TWebSocketPro
             Partial<State<TProvider, TWebSocketProvider>>
         ]
     ]>;
-    constructor({ autoConnect, connectors, provider, storage, webSocketProvider, }?: 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;
@@ -62,7 +57,7 @@ export declare class Client<TProvider extends Provider = Provider, TWebSocketPro
     get error(): Error | undefined;
     get lastUsedChainId(): number | undefined;
     get provider(): TProvider;
-    get status(): "connected" | "connecting" | "reconnecting" | "disconnected";
+    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?: {
@@ -78,5 +73,5 @@ export declare class Client<TProvider extends Provider = Provider, TWebSocketPro
     setLastUsedConnector(lastUsedConnector?: string | null): void;
 }
 export declare let client: Client<Provider, WebSocketProvider>;
-export declare function createClient<TProvider extends Provider = Provider, TWebSocketProvider extends WebSocketProvider = WebSocketProvider>(config?: ClientConfig<TProvider, TWebSocketProvider>): Client<TProvider, TWebSocketProvider>;
+export declare function createClient<TProvider extends Provider = Provider, TWebSocketProvider extends WebSocketProvider = WebSocketProvider>(config: ClientConfig<TProvider, TWebSocketProvider>): Client<TProvider, TWebSocketProvider>;
 export declare function getClient<TProvider extends Provider = Provider, TWebSocketProvider extends WebSocketProvider = WebSocketProvider>(): Client<TProvider, TWebSocketProvider>;

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

@@ -1,5 +1,5 @@
+import { default as EventEmitter } from 'eventemitter3';
 import { Signer } from 'ethers/lib/ethers';
-import { EventEmitter } from '../utils/eventemitter';
 import { Chain } from '../types';
 export declare type ConnectorData<Provider = any> = {
     account?: string;
@@ -42,9 +42,10 @@ export declare abstract class Connector<Provider = any, Options = any> extends E
     abstract getChainId(): Promise<number>;
     abstract getProvider(config?: {
         chainId?: number;
-        create?: boolean;
     }): Promise<Provider>;
-    abstract getSigner(): Promise<Signer>;
+    abstract getSigner(config?: {
+        chainId?: number;
+    }): Promise<Signer>;
     abstract isAuthorized(): Promise<boolean>;
     switchChain?(chainId: number): Promise<Chain>;
     watchAsset?(asset: {

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

@@ -1,5 +1,5 @@
 import { Chain } from '../../types';
-import { Connector } from '../base';
+import { Connector, ConnectorData } from '../base';
 import { MockProvider, MockProviderOptions } from './provider';
 export declare class MockConnector extends Connector<MockProvider, MockProviderOptions> {
     #private;
@@ -12,14 +12,7 @@ export declare class MockConnector extends Connector<MockProvider, MockProviderO
     });
     connect({ chainId }?: {
         chainId?: number;
-    }): Promise<{
-        account: string;
-        chain: {
-            id: number;
-            unsupported: boolean;
-        };
-        provider: MockProvider;
-    }>;
+    }): Promise<Required<ConnectorData<any>>>;
     disconnect(): Promise<void>;
     getAccount(): Promise<string>;
     getChainId(): Promise<number>;

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

@@ -1,3 +1,4 @@
+import { default as EventEmitter } from 'eventemitter3';
 import { Signer, providers } from 'ethers';
 export declare type MockProviderOptions = {
     chainId?: number;
@@ -17,7 +18,7 @@ declare type Events = {
 declare type Event = keyof Events;
 export declare class MockProvider extends providers.BaseProvider {
     #private;
-    events: import("../../utils/eventemitter")<Events, any>;
+    events: EventEmitter<Events, any>;
     constructor(options: MockProviderOptions);
     enable(): Promise<string[]>;
     disconnect(): Promise<void>;

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

@@ -25,11 +25,12 @@ export declare class WalletConnectConnector extends Connector<WalletConnectProvi
     disconnect(): Promise<void>;
     getAccount(): Promise<string>;
     getChainId(): Promise<number>;
-    getProvider({ chainId, create, }?: {
-        chainId?: number | undefined;
-        create?: boolean | undefined;
+    getProvider({ chainId }?: {
+        chainId?: number;
     }): Promise<WalletConnectProvider>;
-    getSigner(): Promise<providers.JsonRpcSigner>;
+    getSigner({ chainId }?: {
+        chainId?: number;
+    }): Promise<providers.JsonRpcSigner>;
     isAuthorized(): Promise<boolean>;
     protected onAccountsChanged: (accounts: string[]) => void;
     protected onChainChanged: (chainId: number | string) => void;

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

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

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

@@ -0,0 +1,25 @@
+export declare const multicallInterface: {
+    inputs: {
+        components: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: {
+        components: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+}[];

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

@@ -1,9 +1,11 @@
 import { ChainName } from './chains';
 export declare const defaultAlchemyId = "_gg7wSSi0KMBsdKnGVfHDueq6xMB9EkC";
 export declare const defaultInfuraId = "84842078b09946638c03157f83405213";
-export declare type RpcProviderName = 'alchemy' | 'infura';
+export declare type RpcProviderName = 'alchemy' | 'infura' | 'public';
 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>;
+declare type PublicChains = Extract<ChainName, 'mainnet' | 'ropsten' | 'rinkeby' | 'goerli' | 'kovan' | 'optimism' | 'optimismKovan' | 'polygon' | 'polygonMumbai' | 'arbitrum' | 'arbitrumRinkeby'>;
+export declare const publicRpcUrls: Record<PublicChains, string>;
 export {};