@wagmi/core 0.5.8 → 0.6.1

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

@@ -1,17 +1,15 @@
-import { CallOverrides, Contract } from 'ethers/lib/ethers';
-import { Result } from 'ethers/lib/utils';
-import { GetContractArgs } from './getContract';
-export declare type ReadContractConfig = {
-    addressOrName: GetContractArgs['addressOrName'];
-    /** Arguments to pass contract method */
-    args?: any | any[];
+import { Abi } from 'abitype';
+import { DefaultOptions, GetConfig, GetOverridesForAbiStateMutability, GetReturnType, Options } from '../../types/contracts';
+export declare type ReadContractConfig<TAbi = Abi, TFunctionName = string, TOptions extends Options = DefaultOptions> = GetConfig<{
+    abi: TAbi;
+    functionName: TFunctionName;
     /** 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<Data = Result> = Data;
-export declare function readContract<TContract extends Contract = Contract, Data = Result>({ addressOrName, args, chainId, contractInterface, functionName, overrides, }: ReadContractConfig): Promise<ReadContractResult<Data>>;
+    overrides?: GetOverridesForAbiStateMutability<'pure' | 'view'>;
+}, 'pure' | 'view', TOptions>;
+export declare type ReadContractResult<TAbi = Abi, TFunctionName = string> = GetReturnType<{
+    abi: TAbi;
+    functionName: TFunctionName;
+}>;
+export declare function readContract<TAbi extends Abi | readonly unknown[], TFunctionName extends string>({ address, args, chainId, abi, functionName, overrides, }: ReadContractConfig<TAbi, TFunctionName>): Promise<ReadContractResult<TAbi, TFunctionName>>;

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

@@ -1,19 +1,28 @@
-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'];
+import { Abi } from 'abitype';
+import { ContractsConfig, ContractsResult, DefaultOptions, GetOverridesForAbiStateMutability, Options as Options_ } from '../../types/contracts';
+declare type Options = Options_ & {
+    isContractsOptional?: boolean;
 };
-export declare type ReadContractsConfig = {
-    /** Failures will fail silently */
+export declare type ReadContractsConfig<TContracts extends unknown[], TOptions extends Options = DefaultOptions, _Contracts = readonly [
+    ...ContractsConfig<TContracts, {
+        /** Chain id to use for provider */
+        chainId?: number;
+    }, TOptions>
+]> = {
+    /** Failures in the multicall 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>>;
+    overrides?: GetOverridesForAbiStateMutability<'pure' | 'view'>;
+} & (TOptions['isContractsOptional'] extends true ? {
+    /** Contracts to query */
+    contracts?: _Contracts;
+} : {
+    /** Contracts to query */
+    contracts: _Contracts;
+});
+export declare type ReadContractsResult<TContracts extends unknown[]> = ContractsResult<TContracts>;
+export declare function readContracts<TAbi extends Abi | readonly unknown[], TFunctionName extends string, TContracts extends {
+    abi: TAbi;
+    functionName: TFunctionName;
+}[]>({ allowFailure, contracts, overrides, }: ReadContractsConfig<TContracts>): Promise<ReadContractsResult<TContracts>>;
+export {};

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

@@ -1,14 +1,28 @@
-import { Contract } from 'ethers/lib/ethers';
-import { GetContractArgs } from './getContract';
-declare type Config = {
+import { Abi, AbiEvent, ExtractAbiEvent, ExtractAbiEventNames, Narrow } from 'abitype';
+import { AbiEventParametersToPrimitiveTypes, Event } from '../../types/contracts';
+import { IsNever, NotEqual, Or } from '../../types/utils';
+declare type ContractEventConfig<TAbi extends Abi | readonly unknown[] = Abi, TEventName extends string = string> = {
+    /** Contract address */
+    address: string;
+    /** Contract ABI */
+    abi: Narrow<TAbi>;
     /** Chain id to use for provider */
     chainId?: number;
+    /** Event to listen for */
+    eventName: IsNever<TEventName> extends true ? string : TEventName;
     /** Receive only a single event */
     once?: boolean;
 };
-export declare function watchContractEvent<TContract extends Contract = Contract>(
-/** Contract configuration */
-contractArgs: GetContractArgs, 
-/** Event name to listen to */
-eventName: Parameters<TContract['on']>[0], callback: Parameters<TContract['on']>[1], { chainId, once }?: Config): () => void;
+declare type GetConfig<T> = T extends {
+    abi: infer TAbi extends Abi;
+} ? ContractEventConfig<TAbi, ExtractAbiEventNames<TAbi>> : T extends {
+    abi: infer TAbi extends readonly unknown[];
+    eventName: infer TEventName extends string;
+} ? ContractEventConfig<TAbi, TEventName> : ContractEventConfig;
+export declare type WatchContractEventConfig<TAbi = Abi, TEventName = string> = GetConfig<{
+    abi: TAbi;
+    eventName: TEventName;
+}>;
+export declare type WatchContractEventCallback<TAbi extends Abi | readonly unknown[] = Abi, TEventName extends string = string, TAbiEvent extends AbiEvent = TAbi extends Abi ? ExtractAbiEvent<TAbi, TEventName> : never> = AbiEventParametersToPrimitiveTypes<TAbiEvent['inputs']> extends infer TArgs extends readonly unknown[] ? Or<IsNever<TArgs>, NotEqual<TAbi, Abi>> extends true ? (...args: any) => void : (...args: [...args: TArgs, event: Event<TAbiEvent>]) => void : never;
+export declare function watchContractEvent<TAbi extends Abi | readonly unknown[], TEventName extends string>({ address, abi, chainId, eventName, once, }: WatchContractEventConfig<TAbi, TEventName>, callback: WatchContractEventCallback<TAbi, TEventName>): () => void;
 export {};

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

@@ -0,0 +1,10 @@
+import { Abi } from 'abitype';
+import { MulticallConfig, MulticallResult } from './multicall';
+export declare type WatchMulticallConfig<TContracts extends unknown[]> = MulticallConfig<TContracts> & {
+    listenToBlock?: boolean;
+};
+export declare type WatchMulticallCallback<TContracts extends unknown[]> = (results: MulticallResult<TContracts>) => void;
+export declare function watchMulticall<TAbi extends Abi | readonly unknown[], TFunctionName extends string, TContracts extends {
+    abi: TAbi;
+    functionName: TFunctionName;
+}[]>(config: WatchMulticallConfig<TContracts>, callback: WatchMulticallCallback<TContracts>): () => void;

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

@@ -1,6 +1,7 @@
+import { Abi, ExtractAbiFunctionNames } from 'abitype';
 import { ReadContractConfig, ReadContractResult } from './readContract';
-export declare type WatchReadContractConfig = ReadContractConfig & {
+export declare type WatchReadContractConfig<TAbi extends Abi | readonly unknown[] = Abi, TFunctionName extends string = string> = ReadContractConfig<TAbi, TFunctionName> & {
     listenToBlock?: boolean;
 };
-export declare type WatchReadContractResult = (result: ReadContractResult) => void;
-export declare function watchReadContract(config: WatchReadContractConfig, callback: WatchReadContractResult): () => void;
+export declare type WatchReadContractCallback<TAbi extends Abi | readonly unknown[], TFunctionName extends string> = (result: ReadContractResult<TAbi, TFunctionName>) => void;
+export declare function watchReadContract<TAbi extends Abi | readonly unknown[], TFunctionName extends TAbi extends Abi ? ExtractAbiFunctionNames<TAbi, 'view' | 'pure'> : string>(config: WatchReadContractConfig<TAbi, TFunctionName>, callback: WatchReadContractCallback<TAbi, TFunctionName>): () => void;

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

@@ -1,6 +1,10 @@
+import { Abi } from 'abitype';
 import { ReadContractsConfig, ReadContractsResult } from './readContracts';
-export declare type WatchReadContractsConfig = ReadContractsConfig & {
+export declare type WatchReadContractsConfig<TContracts extends unknown[]> = ReadContractsConfig<TContracts> & {
     listenToBlock?: boolean;
 };
-export declare type WatchReadContractsResult = (result: ReadContractsResult) => void;
-export declare function watchReadContracts(config: WatchReadContractsConfig, callback: WatchReadContractsResult): () => void;
+export declare type WatchReadContractsCallback<TContracts extends unknown[]> = (results: ReadContractsResult<TContracts>) => void;
+export declare function watchReadContracts<TAbi extends Abi | readonly unknown[], TFunctionName extends string, TContracts extends {
+    abi: TAbi;
+    functionName: TFunctionName;
+}[]>(config: WatchReadContractsConfig<TContracts>, callback: WatchReadContractsCallback<TContracts>): () => void;

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

@@ -1,8 +1,16 @@
-import { CallOverrides, PopulatedTransaction } from 'ethers';
-import { Address } from '../../types';
+import { Abi, Address, ExtractAbiFunction } from 'abitype';
+import { PopulatedTransaction } from 'ethers';
+import { Signer } from '../../types';
+import { DefaultOptions, GetConfig, GetOverridesForAbiStateMutability, Options as Options_ } from '../../types/contracts';
 import { SendTransactionResult } from '../transactions';
-import { GetContractArgs } from './getContract';
-export declare type WriteContractPreparedArgs = {
+declare type Options = Options_ & {
+    isRequestOptional?: boolean;
+};
+declare type Request = PopulatedTransaction & {
+    to: Address;
+    gasLimit: NonNullable<PopulatedTransaction['gasLimit']>;
+};
+export declare type WriteContractPreparedArgs<TOptions extends Options = DefaultOptions> = {
     /**
      * `recklesslyUnprepared`: Allow to pass through unprepared config. Note: This has
      * [UX pitfalls](https://wagmi.sh/docs/prepare-hooks/intro#ux-pitfalls-without-prepare-hooks),
@@ -13,25 +21,36 @@ export declare type WriteContractPreparedArgs = {
      * via the {@link prepareWriteContract} function
      * */
     mode: 'prepared';
+    args?: never;
+    overrides?: never;
+} & (TOptions['isRequestOptional'] extends true ? {
     /** The prepared request. */
-    request: PopulatedTransaction & {
-        to: Address;
-        gasLimit: NonNullable<PopulatedTransaction['gasLimit']>;
-    };
-};
-export declare type WriteContractUnpreparedArgs = {
+    request?: Request;
+} : {
+    /** The prepared request. */
+    request: Request;
+});
+export declare type WriteContractUnpreparedArgs<TAbi = Abi, TFunctionName = string, TOptions extends Options = DefaultOptions> = {
     mode: 'recklesslyUnprepared';
-    request?: undefined;
-};
-export declare type WriteContractArgs = Omit<GetContractArgs, 'signerOrProvider'> & {
-    /** Chain ID used to validate if the signer is connected to the target chain */
+    request?: never;
+} & GetConfig<{
+    abi: TAbi;
+    functionName: TFunctionName;
+    /** Call overrides */
+    overrides?: GetOverridesForAbiStateMutability<[
+        TAbi,
+        TFunctionName
+    ] extends [
+        infer TAbi_ extends Abi,
+        infer TFunctionName_ extends string
+    ] ? ExtractAbiFunction<TAbi_, TFunctionName_>['stateMutability'] : 'nonpayable' | 'payable'>;
+}, 'nonpayable' | 'payable', TOptions>;
+export declare type WriteContractArgs<TAbi = Abi, TFunctionName = string, TOptions extends Options = DefaultOptions> = Omit<GetConfig<{
+    abi: TAbi;
+    functionName: TFunctionName;
+    /** Chain id to use for provider */
     chainId?: number;
-    /** Method to call on contract */
-    functionName: string;
-    /** Arguments to pass contract method */
-    args?: any | any[];
-    overrides?: CallOverrides;
-} & (WriteContractUnpreparedArgs | WriteContractPreparedArgs);
+}, 'nonpayable' | 'payable', TOptions>, 'args'> & (WriteContractUnpreparedArgs<TAbi, TFunctionName, TOptions> | WriteContractPreparedArgs<TOptions>);
 export declare type WriteContractResult = SendTransactionResult;
 /**
  * @description Function to call a contract write method.
@@ -43,10 +62,11 @@ export declare type WriteContractResult = SendTransactionResult;
  * import { prepareWriteContract, writeContract } from '@wagmi/core'
  *
  * const config = await prepareWriteContract({
- *   addressOrName: '0x...',
- *   contractInterface: wagmiAbi,
+ *   address: '0x...',
+ *   abi: wagmiAbi,
  *   functionName: 'mint',
  * })
  * const result = await writeContract(config)
  */
-export declare function writeContract({ addressOrName, args, chainId, contractInterface, functionName, mode, overrides, request: request_, }: WriteContractArgs): Promise<WriteContractResult>;
+export declare function writeContract<TAbi extends Abi | readonly unknown[], TFunctionName extends string, TSigner extends Signer = Signer>({ address, args, chainId, abi, functionName, mode, overrides, request: request_, }: WriteContractArgs<TAbi, TFunctionName>): Promise<WriteContractResult>;
+export {};

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

@@ -1,4 +1,4 @@
-import { Address } from '../../types';
+import { Address } from 'abitype';
 export declare type FetchEnsAddressArgs = {
     /** Chain id to use for provider */
     chainId?: number;

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

@@ -1,6 +1,7 @@
+import { Address } from 'abitype';
 export declare type FetchEnsNameArgs = {
     /** Address to lookup */
-    address: string;
+    address: Address;
     /** Chain id to use for provider */
     chainId?: number;
 };

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

@@ -1,6 +1,6 @@
-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 { deprecatedWriteContract, fetchToken, getContract, prepareWriteContract, readContract, readContracts, watchContractEvent, watchReadContract, watchReadContracts, writeContract, type DeprecatedWriteContractConfig, type DeprecatedWriteContractResult, type FetchTokenArgs, type FetchTokenResult, 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 { connect, disconnect, fetchBalance, fetchSigner, getAccount, getNetwork, signMessage, signTypedData, switchNetwork, watchAccount, watchNetwork, watchSigner, type ConnectArgs, type ConnectResult, type FetchBalanceArgs, type FetchBalanceResult, type FetchSignerArgs, 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 { fetchToken, getContract, multicall, prepareWriteContract, readContract, readContracts, watchContractEvent, watchMulticall, watchReadContract, watchReadContracts, writeContract, type FetchTokenArgs, type FetchTokenResult, type GetContractArgs, type GetContractResult, type MulticallConfig, type MulticallResult, type PrepareWriteContractConfig, type PrepareWriteContractResult, type ReadContractConfig, type ReadContractResult, type ReadContractsConfig, type ReadContractsResult, type WatchMulticallConfig, type WatchMulticallCallback, type WatchReadContractConfig, type WatchReadContractCallback, type WatchReadContractsConfig, type WatchReadContractsCallback, 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 { deprecatedSendTransaction, fetchTransaction, prepareSendTransaction, sendTransaction, waitForTransaction, type DeprecatedSendTransactionArgs, type DeprecatedSendTransactionResult, type FetchTransactionArgs, type FetchTransactionResult, type PrepareSendTransactionArgs, type PrepareSendTransactionResult, type SendTransactionArgs, type SendTransactionPreparedRequest, type SendTransactionResult, type SendTransactionUnpreparedRequest, type WaitForTransactionArgs, type WaitForTransactionResult, } from './transactions';
+export { fetchTransaction, prepareSendTransaction, sendTransaction, waitForTransaction, type FetchTransactionArgs, type FetchTransactionResult, 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,4 +1,3 @@
-export { deprecatedSendTransaction, type DeprecatedSendTransactionArgs, type DeprecatedSendTransactionResult, } from './deprecatedSendTransaction';
 export { fetchTransaction, type FetchTransactionArgs, type FetchTransactionResult, } from './fetchTransaction';
 export { prepareSendTransaction, type PrepareSendTransactionArgs, type PrepareSendTransactionResult, } from './prepareSendTransaction';
 export { sendTransaction, type SendTransactionArgs, type SendTransactionPreparedRequest, type SendTransactionResult, type SendTransactionUnpreparedRequest, } from './sendTransaction';

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

@@ -1,13 +1,14 @@
+import { Address } from 'abitype';
 import { providers } from 'ethers';
-import { Address } from '../../types';
-export declare type PrepareSendTransactionArgs = {
+import { Signer } from '../../types';
+export declare type PrepareSendTransactionArgs<TSigner extends Signer = Signer> = {
     /** 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;
+    signer?: TSigner | null;
 };
 export declare type PrepareSendTransactionResult = {
     chainId?: number;
@@ -33,4 +34,4 @@ export declare type PrepareSendTransactionResult = {
  * })
  * const result = await sendTransaction(config)
  */
-export declare function prepareSendTransaction({ chainId, request, signerOrProvider, }: PrepareSendTransactionArgs): Promise<PrepareSendTransactionResult>;
+export declare function prepareSendTransaction({ chainId, request, signer: signer_, }: PrepareSendTransactionArgs): Promise<PrepareSendTransactionResult>;

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

@@ -1,5 +1,6 @@
+import { Address } from 'abitype';
 import { providers } from 'ethers';
-import { Address } from '../../types';
+import { Hash } from '../../types';
 export declare type SendTransactionPreparedRequest = {
     /**
      * `recklesslyUnprepared`: Allow to pass through an unprepared `request`. Note: This has
@@ -26,7 +27,7 @@ export declare type SendTransactionArgs = {
     chainId?: number;
 } & (SendTransactionPreparedRequest | SendTransactionUnpreparedRequest);
 export declare type SendTransactionResult = {
-    hash: providers.TransactionResponse['hash'];
+    hash: Hash;
     wait: providers.TransactionResponse['wait'];
 };
 /**

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

@@ -1,4 +1,5 @@
 import { providers } from 'ethers';
+import { Hash } from '../../types';
 export declare type WaitForTransactionArgs = {
     /** Chain id to use for provider */
     chainId?: number;
@@ -8,7 +9,7 @@ export declare type WaitForTransactionArgs = {
      */
     confirmations?: number;
     /** Transaction hash to monitor */
-    hash?: string;
+    hash?: Hash;
     timeout?: number;
     /** Function resolving to transaction receipt */
     wait?: providers.TransactionResponse['wait'];

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

@@ -1,7 +1,8 @@
+import { Address } from 'abitype';
 import { default as EventEmitter } from 'eventemitter3';
 import { Chain } from '../types';
 export declare type ConnectorData<Provider = any> = {
-    account?: string;
+    account?: Address;
     chain?: {
         id: number;
         unsupported: boolean;
@@ -37,7 +38,7 @@ export declare abstract class Connector<Provider = any, Options = any, Signer =
         chainId?: number;
     }): Promise<Required<ConnectorData>>;
     abstract disconnect(): Promise<void>;
-    abstract getAccount(): Promise<string>;
+    abstract getAccount(): Promise<Address>;
     abstract getChainId(): Promise<number>;
     abstract getProvider(config?: {
         chainId?: number;
@@ -53,9 +54,9 @@ export declare abstract class Connector<Provider = any, Options = any, Signer =
         image?: string;
         symbol: string;
     }): Promise<boolean>;
-    protected abstract onAccountsChanged(accounts: string[]): void;
+    protected abstract onAccountsChanged(accounts: Address[]): void;
     protected abstract onChainChanged(chain: number | string): void;
     protected abstract onDisconnect(error: Error): void;
-    protected getBlockExplorerUrls(chain: Chain): any[];
+    protected getBlockExplorerUrls(chain: Chain): string[];
     protected isChainUnsupported(chainId: number): boolean;
 }

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

@@ -27,7 +27,7 @@ export declare class CoinbaseWalletConnector extends Connector<CoinbaseWalletPro
     connect({ chainId }?: {
         chainId?: number;
     }): Promise<{
-        account: string;
+        account: `0x${string}`;
         chain: {
             id: number;
             unsupported: boolean;
@@ -35,10 +35,12 @@ export declare class CoinbaseWalletConnector extends Connector<CoinbaseWalletPro
         provider: providers.Web3Provider;
     }>;
     disconnect(): Promise<void>;
-    getAccount(): Promise<string>;
+    getAccount(): Promise<`0x${string}`>;
     getChainId(): Promise<number>;
     getProvider(): Promise<CoinbaseWalletProvider>;
-    getSigner(): Promise<providers.JsonRpcSigner>;
+    getSigner({ chainId }?: {
+        chainId?: number;
+    }): Promise<providers.JsonRpcSigner>;
     isAuthorized(): Promise<boolean>;
     switchChain(chainId: number): Promise<Chain>;
     watchAsset({ address, decimals, image, symbol, }: {

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

@@ -1,3 +1,4 @@
+import { Address } from 'abitype';
 import { providers } from 'ethers';
 import { Chain } from '../types';
 import { Connector } from './base';
@@ -6,14 +7,12 @@ export declare type InjectedConnectorOptions = {
     name?: string | ((detectedName: string | string[]) => string);
     /**
      * MetaMask 10.9.3 emits disconnect event when chain is changed.
-     * This flag prevents the `"disconnect"` event from being emitted upon switching chains.
-     * @see https://github.com/MetaMask/metamask-extension/issues/13375#issuecomment-1027663334
+     * This flag prevents the `"disconnect"` event from being emitted upon switching chains. See [GitHub issue](https://github.com/MetaMask/metamask-extension/issues/13375#issuecomment-1027663334) for more info.
      */
     shimChainChangedDisconnect?: boolean;
     /**
      * MetaMask and other injected providers do not support programmatic disconnect.
-     * This flag simulates the disconnect behavior by keeping track of connection status in storage.
-     * @see https://github.com/MetaMask/metamask-extension/issues/10353
+     * This flag simulates the disconnect behavior by keeping track of connection status in storage. See [GitHub issue](https://github.com/MetaMask/metamask-extension/issues/10353) for more info.
      * @default true
      */
     shimDisconnect?: boolean;
@@ -24,14 +23,14 @@ export declare class InjectedConnector extends Connector<Window['ethereum'], Inj
     readonly name: string;
     readonly ready: boolean;
     protected shimDisconnectKey: string;
-    constructor({ chains, options, }?: {
+    constructor({ chains, options: options_, }?: {
         chains?: Chain[];
         options?: InjectedConnectorOptions;
     });
     connect({ chainId }?: {
         chainId?: number;
     }): Promise<{
-        account: string;
+        account: `0x${string}`;
         chain: {
             id: number;
             unsupported: boolean;
@@ -39,14 +38,16 @@ export declare class InjectedConnector extends Connector<Window['ethereum'], Inj
         provider: import("../types").Ethereum;
     }>;
     disconnect(): Promise<void>;
-    getAccount(): Promise<string>;
+    getAccount(): Promise<`0x${string}`>;
     getChainId(): Promise<number>;
     getProvider(): Promise<import("../types").Ethereum | undefined>;
-    getSigner(): Promise<providers.JsonRpcSigner>;
+    getSigner({ chainId }?: {
+        chainId?: number;
+    }): Promise<providers.JsonRpcSigner>;
     isAuthorized(): Promise<boolean>;
     switchChain(chainId: number): Promise<Chain>;
     watchAsset({ address, decimals, image, symbol, }: {
-        address: string;
+        address: Address;
         decimals?: number;
         image?: string;
         symbol: string;

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

@@ -17,7 +17,7 @@ export declare class MetaMaskConnector extends InjectedConnector {
     connect({ chainId }?: {
         chainId?: number;
     }): Promise<{
-        account: string;
+        account: `0x${string}`;
         chain: {
             id: number;
             unsupported: boolean;

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

@@ -14,7 +14,7 @@ export declare class MockConnector extends Connector<MockProvider, MockProviderO
         chainId?: number;
     }): Promise<Required<ConnectorData<any>>>;
     disconnect(): Promise<void>;
-    getAccount(): Promise<string>;
+    getAccount(): Promise<`0x${string}`>;
     getChainId(): Promise<number>;
     getProvider({ chainId }?: {
         chainId?: number;

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

@@ -23,7 +23,7 @@ export declare class MockProvider extends providers.BaseProvider {
     constructor(options: MockProviderOptions);
     enable(): Promise<string[]>;
     disconnect(): Promise<void>;
-    getAccounts(): Promise<string[]>;
+    getAccounts(): Promise<`0x${string}`[]>;
     getSigner(): import("ethers").Signer;
     switchChain(chainId: number): Promise<void>;
     watchAsset(_asset: {

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

@@ -16,7 +16,7 @@ export declare class WalletConnectConnector extends Connector<WalletConnectProvi
     connect({ chainId }?: {
         chainId?: number;
     }): Promise<{
-        account: string;
+        account: `0x${string}`;
         chain: {
             id: number;
             unsupported: boolean;
@@ -24,7 +24,7 @@ export declare class WalletConnectConnector extends Connector<WalletConnectProvi
         provider: providers.Web3Provider;
     }>;
     disconnect(): Promise<void>;
-    getAccount(): Promise<string>;
+    getAccount(): Promise<`0x${string}`>;
     getChainId(): Promise<number>;
     getProvider({ chainId, create, }?: {
         chainId?: number;