@wagmi/core 0.4.9 → 0.5.0-prepare-hooks.0

package/connectors/walletLink/dist/wagmi-core-connectors-walletLink.cjs.d.ts

@@ -0,0 +1,11 @@
+// are you seeing an error that a default export doesn't exist but your source file has a default export?
+// you should run `yarn` or `yarn preconstruct dev` if preconstruct dev isn't in your postinstall hook
+
+// curious why you need to?
+// this file exists so that you can import from the entrypoint normally
+// except that it points to your source file and you don't need to run build constantly
+// which means we need to re-export all of the modules from your source file
+// and since export * doesn't include default exports, we need to read your source file
+// to check for a default export and re-export it if it exists
+// it's not ideal, but it works pretty well ¯\_(ツ)_/¯
+export * from "../../../src/connectors/walletLink";

package/connectors/walletLink/dist/wagmi-core-connectors-walletLink.cjs.js

@@ -0,0 +1,16 @@
+"use strict";
+// this file might look strange and you might be wondering what it's for
+// it's lets you import your source files by importing this entrypoint
+// as you would import it if it was built with preconstruct build
+// this file is slightly different to some others though
+// it has a require hook which compiles your code with Babel
+// this means that you don't have to set up @babel/register or anything like that
+// but you can still require this module and it'll be compiled
+
+// this bit of code imports the require hook and registers it
+let unregister = require("../../../../../node_modules/.pnpm/@preconstruct+hook@0.4.0/node_modules/@preconstruct/hook").___internalHook(typeof __dirname === 'undefined' ? undefined : __dirname, "../../../../..", "../../..");
+
+// this re-exports the source file
+module.exports = require("../../../src/connectors/walletLink.ts");
+
+unregister();

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

@@ -1,3 +1,3 @@
-import { Signer } from 'ethers/lib/ethers';
-export declare type FetchSignerResult = Signer | null;
-export declare function fetchSigner(): Promise<FetchSignerResult>;
+import { Signer } from '../../types';
+export declare type FetchSignerResult<TSigner extends Signer = Signer> = TSigner | null;
+export declare function fetchSigner<TSigner extends Signer = Signer>(): Promise<FetchSignerResult<TSigner>>;

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

@@ -1,7 +1,8 @@
+export { prepareWriteContract, type PrepareWriteContractConfig, type PrepareWriteContractResult, } from './prepareWriteContract';
 export { getContract, type GetContractArgs } from './getContract';
 export { readContract, type ReadContractConfig, type ReadContractResult, } from './readContract';
 export { readContracts, type ReadContractsConfig, type ReadContractsResult, } from './readContracts';
 export { watchContractEvent } from './watchContractEvent';
 export { watchReadContract, type WatchReadContractConfig, type WatchReadContractResult, } from './watchReadContract';
 export { watchReadContracts, type WatchReadContractsConfig, type WatchReadContractsResult, } from './watchReadContracts';
-export { writeContract, type WriteContractConfig, type WriteContractResult, } from './writeContract';
+export { writeContract, type WriteContractArgs, type WriteContractPreparedArgs, type WriteContractResult, type WriteContractUnpreparedArgs, } from './writeContract';

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

@@ -0,0 +1,37 @@
+import { CallOverrides, Contract, PopulatedTransaction } from 'ethers/lib/ethers';
+import { Address, Signer } from '../../types';
+import { GetContractArgs } from './getContract';
+export declare type PrepareWriteContractConfig<TSigner extends Signer = Signer> = Omit<GetContractArgs, 'signerOrProvider'> & {
+    /** Chain ID used to validate if the signer is connected to the target chain */
+    chainId?: number;
+    /** Method to call on contract */
+    functionName: string;
+    /** Arguments to pass contract method */
+    args?: any | any[];
+    overrides?: CallOverrides;
+    signer?: TSigner | null;
+};
+export declare type PrepareWriteContractResult<TSigner extends Signer = Signer> = PrepareWriteContractConfig<TSigner> & {
+    chainId?: number;
+    request: PopulatedTransaction & {
+        to: Address;
+        gasLimit: NonNullable<PopulatedTransaction['gasLimit']>;
+    };
+    mode: 'prepared';
+};
+/**
+ * @description Prepares the parameters required for a contract write transaction.
+ *
+ * Returns config to be passed through to `writeContract`.
+ *
+ * @example
+ * import { prepareWriteContract, writeContract } from '@wagmi/core'
+ *
+ * const config = await prepareWriteContract({
+ *  addressOrName: '0x...',
+ *  contractInterface: wagmiAbi,
+ *  functionName: 'mint',
+ * })
+ * const result = await writeContract(config)
+ */
+export declare function prepareWriteContract<TContract extends Contract = Contract, TSigner extends Signer = Signer>({ addressOrName, args, chainId, contractInterface, functionName, overrides, signer: signer_, }: PrepareWriteContractConfig): Promise<PrepareWriteContractResult<TSigner>>;

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

@@ -1,16 +1,52 @@
-import { CallOverrides, Contract, providers } from 'ethers';
+import { CallOverrides, PopulatedTransaction } from 'ethers';
+import { Address } from '../../types';
+import { SendTransactionResult } from '../transactions';
 import { GetContractArgs } from './getContract';
-export declare type WriteContractConfig = GetContractArgs & {
+export declare type WriteContractPreparedArgs = {
     /**
-     * Chain id to use for write
-     * If signer is not active on this chain, it will attempt to programmatically switch
-     */
+     * `dangerouslyUnprepared`: Allow to pass through unprepared config. Note: This has
+     * [UX pitfalls](https://wagmi.sh/docs/prepare-hooks/intro#ux-pitfalls-without-prepare-hooks),
+     * it is highly recommended to not use this and instead prepare the request upfront
+     * using the {@link prepareWriteContract} function.
+     *
+     * `prepared`: The request has been prepared with parameters required for sending a transaction
+     * via the {@link prepareWriteContract} function
+     * */
+    mode: 'prepared';
+    /** The prepared request. */
+    request: PopulatedTransaction & {
+        to: Address;
+        gasLimit: NonNullable<PopulatedTransaction['gasLimit']>;
+    };
+};
+export declare type WriteContractUnpreparedArgs = {
+    mode: 'dangerouslyUnprepared';
+    request?: undefined;
+};
+export declare type WriteContractArgs = Omit<GetContractArgs, 'signerOrProvider'> & {
+    /** Chain ID used to validate if the signer is connected to the target chain */
     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<TContract extends Contract = Contract>({ addressOrName, args, chainId, contractInterface, functionName, overrides, signerOrProvider, }: WriteContractConfig): Promise<WriteContractResult>;
+} & (WriteContractUnpreparedArgs | WriteContractPreparedArgs);
+export declare type WriteContractResult = SendTransactionResult;
+/**
+ * @description Function to call a contract write method.
+ *
+ * It is recommended to pair this with the {@link prepareWriteContract} function
+ * to avoid [UX pitfalls](https://wagmi.sh/docs/prepare-hooks/intro#ux-pitfalls-without-prepare-hooks).
+ *
+ * @example
+ * import { prepareWriteContract, writeContract } from '@wagmi/core'
+ *
+ * const config = await prepareWriteContract({
+ *   addressOrName: '0x...',
+ *   contractInterface: wagmiAbi,
+ *   functionName: 'mint',
+ * })
+ * const result = await writeContract(config)
+ */
+export declare function writeContract({ addressOrName, args, chainId, contractInterface, functionName, mode, overrides, request: request_, }: WriteContractArgs): Promise<WriteContractResult>;

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

@@ -1,8 +1,9 @@
+import { Address } from '../../types';
 export declare type FetchEnsAddressArgs = {
     /** Chain id to use for provider */
     chainId?: number;
     /** ENS name to resolve */
     name: string;
 };
-export declare type FetchEnsAddressResult = string | null;
+export declare type FetchEnsAddressResult = Address | null;
 export declare function fetchEnsAddress({ chainId, name, }: FetchEnsAddressArgs): Promise<FetchEnsAddressResult>;

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

@@ -1,7 +1,7 @@
 export { connect, disconnect, fetchBalance, fetchSigner, getAccount, getNetwork, signMessage, signTypedData, switchNetwork, watchAccount, watchNetwork, watchSigner, type ConnectArgs, type ConnectResult, type FetchBalanceArgs, type FetchBalanceResult, type FetchSignerResult, type GetAccountResult, type GetNetworkResult, type SignMessageArgs, type SignMessageResult, type SignTypedDataArgs, type SignTypedDataResult, type SwitchNetworkArgs, type SwitchNetworkResult, type WatchAccountCallback, type WatchNetworkCallback, type WatchSignerCallback, } from './accounts';
-export { getContract, readContract, 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 { getContract, prepareWriteContract, readContract, readContracts, watchContractEvent, watchReadContract, watchReadContracts, writeContract, type GetContractArgs, type PrepareWriteContractConfig, type PrepareWriteContractResult, type ReadContractConfig, type ReadContractResult, type ReadContractsConfig, type ReadContractsResult, type WatchReadContractConfig, type WatchReadContractResult, type WatchReadContractsConfig, type WatchReadContractsResult, type WriteContractArgs, type WriteContractPreparedArgs, type WriteContractResult, type WriteContractUnpreparedArgs, } from './contracts';
 export { fetchEnsAddress, fetchEnsAvatar, fetchEnsName, fetchEnsResolver, type FetchEnsAddressArgs, type FetchEnsAddressResult, type FetchEnsAvatarArgs, type FetchEnsAvatarResult, type FetchEnsNameArgs, type FetchEnsNameResult, type FetchEnsResolverArgs, type FetchEnsResolverResult, } from './ens';
 export { fetchBlockNumber, fetchFeeData, watchBlockNumber, type FetchBlockNumberArgs, type FetchBlockNumberResult, type FetchFeeDataArgs, type FetchFeeDataResult, type WatchBlockNumberArgs, type WatchBlockNumberCallback, } from './network-status';
 export { getProvider, getWebSocketProvider, watchProvider, watchWebSocketProvider, type GetProviderArgs, type GetProviderResult, type GetWebSocketProviderArgs, type GetWebSocketProviderResult, type WatchProviderCallback, type WatchWebSocketProviderCallback, } from './providers';
 export { fetchToken, type FetchTokenArgs, type FetchTokenResult, } from './tokens';
-export { sendTransaction, waitForTransaction, type SendTransactionArgs, type SendTransactionResult, type WaitForTransactionArgs, type WaitForTransactionResult, } from './transactions';
+export { prepareSendTransaction, sendTransaction, waitForTransaction, type PrepareSendTransactionArgs, type PrepareSendTransactionResult, type SendTransactionArgs, type SendTransactionPreparedRequest, type SendTransactionResult, type SendTransactionUnpreparedRequest, type WaitForTransactionArgs, type WaitForTransactionResult, } from './transactions';

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

@@ -1,2 +1,3 @@
-export { sendTransaction, type SendTransactionArgs, type SendTransactionResult, } from './sendTransaction';
+export { prepareSendTransaction, type PrepareSendTransactionArgs, type PrepareSendTransactionResult, } from './prepareSendTransaction';
+export { sendTransaction, type SendTransactionArgs, type SendTransactionPreparedRequest, type SendTransactionResult, type SendTransactionUnpreparedRequest, } from './sendTransaction';
 export { waitForTransaction, type WaitForTransactionArgs, type WaitForTransactionResult, } from './waitForTransaction';

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

@@ -0,0 +1,36 @@
+import { providers } from 'ethers';
+import { Address } from '../../types';
+export declare type PrepareSendTransactionArgs = {
+    /** Chain ID used to validate if the signer is connected to the target chain */
+    chainId?: number;
+    /** Request data to prepare the transaction */
+    request: providers.TransactionRequest & {
+        to: NonNullable<providers.TransactionRequest['to']>;
+    };
+    signerOrProvider?: providers.JsonRpcSigner | providers.Provider;
+};
+export declare type PrepareSendTransactionResult = {
+    chainId?: number;
+    request: providers.TransactionRequest & {
+        to: Address;
+        gasLimit: NonNullable<providers.TransactionRequest['gasLimit']>;
+    };
+    mode: 'prepared';
+};
+/**
+ * @description Prepares the parameters required for sending a transaction.
+ *
+ * Returns config to be passed through to `sendTransaction`.
+ *
+ * @example
+ * import { prepareSendTransaction, sendTransaction } from '@wagmi/core'
+ *
+ * const config = await prepareSendTransaction({
+ *  request: {
+ *    to: 'moxey.eth',
+ *    value: parseEther('1'),
+ *  }
+ * })
+ * const result = await sendTransaction(config)
+ */
+export declare function prepareSendTransaction({ chainId, request, signerOrProvider, }: PrepareSendTransactionArgs): Promise<PrepareSendTransactionResult>;

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

@@ -1,12 +1,47 @@
 import { providers } from 'ethers';
-export declare type SendTransactionArgs = {
+import { Address } from '../../types';
+export declare type SendTransactionPreparedRequest = {
     /**
-     * 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 */
+     * `dangerouslyUnprepared`: Allow to pass through an unprepared `request`. Note: This has
+     * [UX pitfalls](/docs/prepare-hooks/intro#ux-pitfalls-without-prepare-hooks), it is highly recommended
+     * to not use this and instead prepare the request upfront using the `prepareSendTransaction` function.
+     *
+     * `prepared`: The request has been prepared with parameters required for sending a transaction
+     * via the `prepareSendTransaction` function
+     * */
+    mode: 'prepared';
+    /** The prepared request for sending a transaction. */
+    request: providers.TransactionRequest & {
+        to: Address;
+        gasLimit: NonNullable<providers.TransactionRequest['gasLimit']>;
+    };
+};
+export declare type SendTransactionUnpreparedRequest = {
+    mode: 'dangerouslyUnprepared';
+    /** The unprepared request for sending a transaction. */
     request: providers.TransactionRequest;
 };
-export declare type SendTransactionResult = providers.TransactionResponse;
-export declare function sendTransaction({ chainId, request, }: SendTransactionArgs): Promise<SendTransactionResult>;
+export declare type SendTransactionArgs = {
+    /** Chain ID used to validate if the signer is connected to the target chain */
+    chainId?: number;
+} & (SendTransactionPreparedRequest | SendTransactionUnpreparedRequest);
+export declare type SendTransactionResult = {
+    hash: providers.TransactionResponse['hash'];
+    wait: providers.TransactionResponse['wait'];
+};
+/**
+ * @description Function to send a transaction.
+ *
+ * It is recommended to pair this with the `prepareSendTransaction` function to avoid
+ * [UX pitfalls](https://wagmi.sh/docs/prepare-hooks/intro#ux-pitfalls-without-prepare-hooks).
+ *
+ * @example
+ * import { prepareSendTransaction, sendTransaction } from '@wagmi/core'
+ *
+ * const config = await prepareSendTransaction({
+ *  to: 'moxey.eth',
+ *  value: parseEther('1'),
+ * })
+ * const result = await sendTransaction(config)
+ */
+export declare function sendTransaction({ chainId, mode, request, }: SendTransactionArgs): Promise<SendTransactionResult>;

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

@@ -51,8 +51,8 @@ export declare class Client<TProvider extends Provider = Provider, TWebSocketPro
     ]>;
     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;
+    get connectors(): Connector<any, any, any>[];
+    get connector(): Connector<any, any, any> | undefined;
     get data(): Data<TProvider> | undefined;
     get error(): Error | undefined;
     get lastUsedChainId(): number | undefined;

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

@@ -1,5 +1,4 @@
 import { default as EventEmitter } from 'eventemitter3';
-import { Signer } from 'ethers/lib/ethers';
 import { Chain } from '../types';
 export declare type ConnectorData<Provider = any> = {
     account?: string;
@@ -19,7 +18,7 @@ export interface ConnectorEvents<Provider = any> {
     disconnect(): void;
     error(error: Error): void;
 }
-export declare abstract class Connector<Provider = any, Options = any> extends EventEmitter<ConnectorEvents<Provider>> {
+export declare abstract class Connector<Provider = any, Options = any, Signer = any> extends EventEmitter<ConnectorEvents<Provider>> {
     /** Unique connector id */
     abstract readonly id: string;
     /** Connector name */

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

@@ -15,7 +15,7 @@ declare type Options = CoinbaseWalletSDKOptions & {
      */
     chainId?: number;
 };
-export declare class CoinbaseWalletConnector extends Connector<CoinbaseWalletProvider, Options> {
+export declare class CoinbaseWalletConnector extends Connector<CoinbaseWalletProvider, Options, providers.JsonRpcSigner> {
     #private;
     readonly id = "coinbaseWallet";
     readonly name = "Coinbase Wallet";

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

@@ -18,7 +18,7 @@ export declare type InjectedConnectorOptions = {
      */
     shimDisconnect?: boolean;
 };
-export declare class InjectedConnector extends Connector<Window['ethereum'], InjectedConnectorOptions | undefined> {
+export declare class InjectedConnector extends Connector<Window['ethereum'], InjectedConnectorOptions | undefined, providers.JsonRpcSigner> {
     #private;
     readonly id: string;
     readonly name: string;

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

@@ -19,7 +19,7 @@ export declare class MockConnector extends Connector<MockProvider, MockProviderO
     getProvider({ chainId }?: {
         chainId?: number;
     }): Promise<MockProvider>;
-    getSigner(): Promise<import("ethers").Signer>;
+    getSigner(): Promise<import("@ethersproject/providers").JsonRpcSigner>;
     isAuthorized(): Promise<boolean>;
     watchAsset(asset: {
         address: string;

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

@@ -1,5 +1,5 @@
 import { default as EventEmitter } from 'eventemitter3';
-import { Signer, providers } from 'ethers';
+import { providers } from 'ethers';
 export declare type MockProviderOptions = {
     chainId?: number;
     flags?: {
@@ -8,7 +8,7 @@ export declare type MockProviderOptions = {
         failSwitchChain?: boolean;
         noSwitchChain?: boolean;
     };
-    signer: Signer;
+    signer: providers.JsonRpcSigner;
 };
 declare type Events = {
     accountsChanged(accounts: string[]): void;
@@ -23,7 +23,7 @@ export declare class MockProvider extends providers.BaseProvider {
     enable(): Promise<string[]>;
     disconnect(): Promise<void>;
     getAccounts(): Promise<string[]>;
-    getSigner(): Signer;
+    getSigner(): providers.JsonRpcSigner;
     switchChain(chainId: number): Promise<void>;
     watchAsset(_asset: {
         address: string;

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

@@ -3,7 +3,8 @@ import type WalletConnectProvider from '@walletconnect/ethereum-provider';
 import { Chain } from '../types';
 import { Connector } from './base';
 declare type WalletConnectOptions = ConstructorParameters<typeof WalletConnectProvider>[0];
-export declare class WalletConnectConnector extends Connector<WalletConnectProvider, WalletConnectOptions> {
+declare type WalletConnectSigner = providers.JsonRpcSigner;
+export declare class WalletConnectConnector extends Connector<WalletConnectProvider, WalletConnectOptions, WalletConnectSigner> {
     #private;
     readonly id = "walletConnect";
     readonly name = "WalletConnect";

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

@@ -1,5 +1,4 @@
 import { Connector } from './connectors';
-import { BlockExplorer } from './constants';
 import { Chain } from './types';
 /**
  * Error subclass implementing JSON RPC 2.0 errors and Ethereum RPC errors per EIP-1474.
@@ -71,11 +70,19 @@ export declare class ConnectorNotFoundError extends Error {
     name: string;
     message: string;
 }
+export declare class ContractMethodDoesNotExistError extends Error {
+    name: string;
+    constructor({ addressOrName, chainId, functionName, }: {
+        addressOrName: string;
+        chainId?: number;
+        functionName: string;
+    });
+}
 export declare class ContractMethodNoResultError extends Error {
     name: string;
-    constructor({ addressOrName, blockExplorer, functionName, }: {
+    constructor({ addressOrName, chainId, functionName, }: {
         addressOrName: string;
-        blockExplorer?: BlockExplorer;
+        chainId?: number;
         functionName: string;
     });
 }

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

@@ -1,13 +1,13 @@
-export { connect, disconnect, fetchBalance, fetchBlockNumber, fetchEnsAddress, fetchEnsAvatar, fetchEnsName, fetchEnsResolver, fetchFeeData, fetchSigner, fetchToken, getAccount, getContract, getNetwork, getProvider, getWebSocketProvider, readContract, readContracts, sendTransaction, signMessage, signTypedData, switchNetwork, waitForTransaction, watchAccount, watchBlockNumber, watchContractEvent, watchNetwork, watchProvider, watchReadContract, watchReadContracts, 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, ReadContractConfig, ReadContractResult, ReadContractsConfig, ReadContractsResult, SendTransactionArgs, SendTransactionResult, SignMessageArgs, SignMessageResult, SignTypedDataArgs, SignTypedDataResult, SwitchNetworkArgs, SwitchNetworkResult, WaitForTransactionArgs, WaitForTransactionResult, WatchAccountCallback, WatchBlockNumberArgs, WatchBlockNumberCallback, WatchNetworkCallback, WatchReadContractConfig, WatchReadContractResult, WatchProviderCallback, WatchSignerCallback, WatchWebSocketProviderCallback, WriteContractConfig, WriteContractResult, } from './actions';
+export { connect, disconnect, fetchBalance, fetchBlockNumber, fetchEnsAddress, fetchEnsAvatar, fetchEnsName, fetchEnsResolver, fetchFeeData, fetchSigner, fetchToken, getAccount, getContract, getNetwork, getProvider, getWebSocketProvider, prepareWriteContract, prepareSendTransaction, readContract, readContracts, sendTransaction, signMessage, signTypedData, switchNetwork, waitForTransaction, watchAccount, watchBlockNumber, watchContractEvent, watchNetwork, watchProvider, watchReadContract, watchReadContracts, 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, PrepareWriteContractConfig, PrepareWriteContractResult, PrepareSendTransactionArgs, PrepareSendTransactionResult, ReadContractConfig, ReadContractResult, ReadContractsConfig, ReadContractsResult, SendTransactionArgs, SendTransactionPreparedRequest, SendTransactionResult, SendTransactionUnpreparedRequest, SignMessageArgs, SignMessageResult, SignTypedDataArgs, SignTypedDataResult, SwitchNetworkArgs, SwitchNetworkResult, WaitForTransactionArgs, WaitForTransactionResult, WatchAccountCallback, WatchBlockNumberArgs, WatchBlockNumberCallback, WatchNetworkCallback, WatchReadContractConfig, WatchReadContractResult, WatchProviderCallback, WatchSignerCallback, WatchWebSocketProviderCallback, WriteContractArgs, WriteContractPreparedArgs, WriteContractResult, WriteContractUnpreparedArgs, } from './actions';
 export { createClient, Client } from './client';
 export type { ClientConfig } from './client';
 export { Connector, InjectedConnector } from './connectors';
 export type { ConnectorData, ConnectorEvents, InjectedConnectorOptions, } from './connectors';
 export { alchemyRpcUrls, allChains, chain, chainId, defaultChains, defaultL2Chains, erc20ABI, erc721ABI, etherscanBlockExplorers, infuraRpcUrls, publicRpcUrls, units, } from './constants';
-export { AddChainError, ChainDoesNotSupportMulticallError, ChainMismatchError, ChainNotConfiguredError, ConnectorAlreadyConnectedError, ConnectorNotFoundError, ContractMethodNoResultError, ProviderChainsNotFound, ProviderRpcError, ResourceUnavailableError, RpcError, SwitchChainError, SwitchChainNotSupportedError, UserRejectedRequestError, } from './errors';
+export { AddChainError, ChainDoesNotSupportMulticallError, ChainMismatchError, ChainNotConfiguredError, ConnectorAlreadyConnectedError, ConnectorNotFoundError, ContractMethodDoesNotExistError, ContractMethodNoResultError, ProviderChainsNotFound, ProviderRpcError, ResourceUnavailableError, RpcError, SwitchChainError, SwitchChainNotSupportedError, UserRejectedRequestError, } from './errors';
 export { createStorage, noopStorage } from './storage';
 export type { ClientStorage as Storage } from './storage';
-export type { Chain, ChainProviderFn, Ethereum, FallbackProviderConfig, ProviderWithFallbackConfig, Provider, Unit, WebSocketProvider, } from './types';
+export type { Chain, ChainProviderFn, Ethereum, FallbackProviderConfig, ProviderWithFallbackConfig, Provider, Signer, Unit, WebSocketProvider, } from './types';
 export { configureChains, deepEqual, normalizeChainId, parseContractResult, } from './utils';
 export type { ConfigureChainsConfig } from './utils';

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

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

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

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

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

@@ -1,11 +1,10 @@
 import { providers } from 'ethers';
 import { Chain, ChainProviderFn, 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): ChainProviderFn<providers.JsonRpcProvider, providers.WebSocketProvider>;
+export declare function jsonRpcProvider({ priority, rpc, stallTimeout, static: static_, weight, }: JsonRpcProviderConfig): ChainProviderFn<providers.JsonRpcProvider, providers.WebSocketProvider>;

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

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

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

@@ -1,5 +1,6 @@
-import { providers } from 'ethers';
+import { Signer as BaseSigner, providers } from 'ethers';
 import { BlockExplorer, BlockExplorerName, RpcProviderName, units } from '../constants';
+export declare type Address = `0x${string}`;
 export declare type Chain = {
     /** ID in number form */
     id: number;
@@ -48,6 +49,7 @@ export declare type Provider = providers.BaseProvider & {
 export declare type WebSocketProvider = providers.WebSocketProvider & {
     chains?: Chain[];
 };
+export declare type Signer = BaseSigner;
 export declare type Unit = typeof units[number];
 declare type AddEthereumChainParameter = {
     /** A 0x-prefixed hexadecimal string */

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

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