@wagmi/core 0.8.6 → 0.8.8

package/dist/{chunk-DYHSCPJD.js → chunk-VRBYTA34.js}

@@ -2106,11 +2106,11 @@ function getContract({
 async function prepareWriteContract({
   abi,
   address,
-  args,
   chainId,
   functionName,
   overrides,
-  signer: signer_
+  signer: signer_,
+  ...config
 }) {
   const signer = signer_ ?? await fetchSigner({ chainId });
   if (!signer)
@@ -2122,6 +2122,7 @@ async function prepareWriteContract({
     abi,
     signerOrProvider: signer
   });
+  const args = config.args;
   const normalizedFunctionName = normalizeFunctionName({
     contract,
     functionName,
@@ -2260,11 +2261,12 @@ async function multicall({
     ...params
   );
   return results.map(({ returnData, success }, i) => {
-    const { address, abi, args, functionName } = contracts[i];
+    const { address, abi, functionName, ...rest } = contracts[i];
     const contract = getContract({
       address,
       abi
     });
+    const args = rest.args;
     const normalizedFunctionName = normalizeFunctionName({
       contract,
       functionName,
@@ -2328,11 +2330,11 @@ async function multicall({
 // src/actions/contracts/readContract.ts
 async function readContract({
   address,
-  args,
   chainId,
   abi,
   functionName,
-  overrides
+  overrides,
+  ...config
 }) {
   const provider = getProvider({ chainId });
   const contract = getContract({
@@ -2340,6 +2342,7 @@ async function readContract({
     abi,
     signerOrProvider: provider
   });
+  const args = config.args;
   const normalizedFunctionName = normalizeFunctionName({
     contract,
     functionName,
@@ -2736,6 +2739,39 @@ async function waitForTransaction({
   }
 }
 
+// src/actions/transactions/watchPendingTransactions.ts
+import shallow3 from "zustand/shallow";
+function watchPendingTransactions(args, callback) {
+  let previousProvider;
+  const createListener = (provider) => {
+    if (previousProvider) {
+      previousProvider?.off("pending", callback);
+    }
+    provider.on("pending", callback);
+    previousProvider = provider;
+  };
+  const provider_ = getWebSocketProvider({ chainId: args.chainId }) ?? getProvider({ chainId: args.chainId });
+  createListener(provider_);
+  const client2 = getClient();
+  const unsubscribe = client2.subscribe(
+    ({ provider, webSocketProvider }) => ({ provider, webSocketProvider }),
+    async ({ provider, webSocketProvider }) => {
+      const provider_2 = webSocketProvider ?? provider;
+      if (!args.chainId && provider_2) {
+        createListener(provider_2);
+      }
+    },
+    {
+      equalityFn: shallow3
+    }
+  );
+  return () => {
+    unsubscribe();
+    provider_?.off("pending", callback);
+    previousProvider?.off("pending", callback);
+  };
+}
+
 // src/actions/contracts/writeContract.ts
 async function writeContract({
   address,
@@ -2863,8 +2899,8 @@ function getAccount() {
       };
     case "connecting":
       return {
-        address: void 0,
-        connector: void 0,
+        address: data?.account,
+        connector,
         isConnected: false,
         isConnecting: true,
         isDisconnected: false,
@@ -2967,7 +3003,7 @@ async function switchNetwork({
 }
 
 // src/actions/accounts/watchAccount.ts
-import shallow3 from "zustand/shallow";
+import shallow4 from "zustand/shallow";
 function watchAccount(callback, { selector = (x) => x } = {}) {
   const client2 = getClient();
   const handleChange = () => callback(getAccount());
@@ -2979,14 +3015,14 @@ function watchAccount(callback, { selector = (x) => x } = {}) {
     }),
     handleChange,
     {
-      equalityFn: shallow3
+      equalityFn: shallow4
     }
   );
   return unsubscribe;
 }
 
 // src/actions/accounts/watchNetwork.ts
-import shallow4 from "zustand/shallow";
+import shallow5 from "zustand/shallow";
 function watchNetwork(callback, { selector = (x) => x } = {}) {
   const client2 = getClient();
   const handleChange = () => callback(getNetwork());
@@ -2994,14 +3030,14 @@ function watchNetwork(callback, { selector = (x) => x } = {}) {
     ({ data, chains }) => selector({ chainId: data?.chain?.id, chains }),
     handleChange,
     {
-      equalityFn: shallow4
+      equalityFn: shallow5
     }
   );
   return unsubscribe;
 }
 
 // src/actions/accounts/watchSigner.ts
-import shallow5 from "zustand/shallow";
+import shallow6 from "zustand/shallow";
 function watchSigner({ chainId }, callback) {
   const client2 = getClient();
   const handleChange = async () => {
@@ -3018,7 +3054,7 @@ function watchSigner({ chainId }, callback) {
     }),
     handleChange,
     {
-      equalityFn: shallow5
+      equalityFn: shallow6
     }
   );
   return unsubscribe;
@@ -3320,6 +3356,7 @@ export {
   sendTransaction,
   fetchFeeData,
   waitForTransaction,
+  watchPendingTransactions,
   writeContract,
   fetchBalance,
   fetchSigner,

package/dist/contracts-9eb7706c.d.ts

@@ -0,0 +1,199 @@
+import { Abi, AbiStateMutability, Narrow, Address, ExtractAbiFunctionNames, AbiFunction, ExtractAbiFunction, AbiParametersToPrimitiveTypes, AbiParameterToPrimitiveType, AbiEvent, AbiParameter, ResolvedConfig } from 'abitype';
+import { ethers } from 'ethers';
+
+/**
+ * Count occurrences of {@link TType} in {@link TArray}
+ *
+ * @param TArray - Array to count occurrences in
+ * @param TType - Type to count occurrences of
+ * @returns Number of occurrences of {@link TType} in {@link TArray}
+ *
+ * @example
+ * type Result = CountOccurrences<['foo', 'bar', 'foo'], 'foo'>
+ */
+type CountOccurrences<TArray extends readonly unknown[], TType> = FilterNever<[
+    ...{
+        [K in keyof TArray]: TArray[K] extends TType ? TArray[K] : never;
+    }
+]>['length'];
+/**
+ * Removes all occurrences of `never` from {@link TArray}
+ *
+ * @param TArray - Array to filter
+ * @returns Array with `never` removed
+ *
+ * @example
+ * type Result = FilterNever<[1, 2, never, 3, never, 4]>
+ */
+type FilterNever<TArray extends readonly unknown[]> = TArray['length'] extends 0 ? [] : TArray extends [infer THead, ...infer TRest] ? IsNever<THead> extends true ? FilterNever<TRest> : [THead, ...FilterNever<TRest>] : never;
+/**
+ * Check if {@link T} is `never`
+ *
+ * @param T - Type to check
+ * @returns `true` if {@link T} is `never`, otherwise `false`
+ *
+ * @example
+ * type Result = IsNever<'foo'>
+ */
+type IsNever<T> = [T] extends [never] ? true : false;
+/**
+ * Checks if {@link T} is `unknown`
+ *
+ * @param T - Type to check
+ * @returns `true` if {@link T} is `unknown`, otherwise `false`
+ *
+ * @example
+ * type Result = IsUnknown<unknown>
+ */
+type IsUnknown<T> = unknown extends T ? true : false;
+/**
+ * Joins {@link Items} into string separated by {@link Separator}
+ *
+ * @param Items - Items to join
+ * @param Separator - Separator to use
+ * @returns Joined string
+ *
+ * @example
+ * type Result = Join<['foo', 'bar'], '-'>
+ */
+type Join<Items extends string[], Separator extends string | number> = Items extends [infer First, ...infer Rest] ? First extends string ? Rest extends string[] ? Rest extends [] ? `${First}` : `${First}${Separator}${Join<Rest, Separator>}` : never : never : '';
+/**
+ * Converts {@link Union} to intersection
+ *
+ * @param Union - Union to convert
+ * @returns Intersection of {@link Union}
+ *
+ * @example
+ * type Result = UnionToIntersection<'foo' | 'bar'>
+ */
+type UnionToIntersection<Union> = (Union extends unknown ? (arg: Union) => unknown : never) extends (arg: infer R) => unknown ? R : never;
+
+type Contract<TAbi extends Abi | readonly unknown[] = Abi | readonly unknown[], TFunctionName extends string = string> = {
+    abi: TAbi;
+    functionName: TFunctionName;
+};
+type GetConfig<TAbi extends Abi | readonly unknown[] = Abi, TFunctionName extends string = string, TAbiStateMutability extends AbiStateMutability = AbiStateMutability> = {
+    /** Contract ABI */
+    abi: Narrow<TAbi>;
+    /** Contract address */
+    address: Address;
+    /** Function to invoke on the contract */
+    functionName: GetFunctionName<TAbi, TFunctionName, TAbiStateMutability>;
+} & GetArgs<TAbi, TFunctionName>;
+type GetFunctionName<TAbi extends Abi | readonly unknown[] = Abi, TFunctionName extends string = string, TAbiStateMutability extends AbiStateMutability = AbiStateMutability> = TAbi extends Abi ? ExtractAbiFunctionNames<TAbi, TAbiStateMutability> extends infer AbiFunctionNames ? AbiFunctionNames | (TFunctionName extends AbiFunctionNames ? TFunctionName : never) | (Abi extends TAbi ? string : never) : never : TFunctionName;
+type GetArgs<TAbi extends Abi | readonly unknown[], TFunctionName extends string, TAbiFunction extends AbiFunction & {
+    type: 'function';
+} = TAbi extends Abi ? ExtractAbiFunction<TAbi, TFunctionName> : AbiFunction & {
+    type: 'function';
+}, TArgs = AbiParametersToPrimitiveTypes<TAbiFunction['inputs']>, FailedToParseArgs = ([TArgs] extends [never] ? true : false) | (readonly unknown[] extends TArgs ? true : false)> = true extends FailedToParseArgs ? {
+    /**
+     * Arguments to pass contract method
+     *
+     * Use a [const assertion](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-4.html#const-assertions) on {@link abi} for type inference.
+     */
+    args?: readonly unknown[];
+} : TArgs extends readonly [] ? {
+    args?: never;
+} : {
+    /** Arguments to pass contract method */ args: TArgs;
+};
+type GetReturnType<TAbi extends Abi | readonly unknown[] = Abi, TFunctionName extends string = string, TAbiFunction extends AbiFunction & {
+    type: 'function';
+} = TAbi extends Abi ? ExtractAbiFunction<TAbi, TFunctionName> : AbiFunction & {
+    type: 'function';
+}, TArgs = AbiParametersToPrimitiveTypes<TAbiFunction['outputs']>, FailedToParseArgs = ([TArgs] extends [never] ? true : false) | (readonly unknown[] extends TArgs ? true : false)> = true extends FailedToParseArgs ? unknown : TArgs extends readonly [] ? void : TArgs extends readonly [infer Arg] ? Arg : TArgs & {
+    [Output in TAbiFunction['outputs'][number] as Output extends {
+        name: infer Name extends string;
+    } ? Name extends '' ? never : Name : never]: AbiParameterToPrimitiveType<Output>;
+};
+type MAXIMUM_DEPTH = 20;
+/**
+ * ContractsConfig reducer recursively unwraps function arguments to infer/enforce type param
+ */
+type ContractsConfig<TContracts extends Contract[], TProperties extends Record<string, any> = object, Result extends any[] = [], Depth extends ReadonlyArray<number> = []> = Depth['length'] extends MAXIMUM_DEPTH ? (GetConfig & TProperties)[] : TContracts extends [] ? [] : TContracts extends [infer Head extends Contract] ? [
+    ...Result,
+    GetConfig<Head['abi'], Head['functionName'], 'pure' | 'view'> & TProperties
+] : TContracts extends [
+    infer Head extends Contract,
+    ...infer Tail extends Contract[]
+] ? ContractsConfig<[
+    ...Tail
+], TProperties, [
+    ...Result,
+    GetConfig<Head['abi'], Head['functionName'], 'pure' | 'view'> & TProperties
+], [
+    ...Depth,
+    1
+]> : unknown[] extends TContracts ? TContracts : TContracts extends GetConfig<infer TAbi, infer TFunctionName>[] ? (GetConfig<TAbi, TFunctionName> & TProperties)[] : (GetConfig & TProperties)[];
+/**
+ * ContractsResult reducer recursively maps type param to results
+ */
+type ContractsResult<TContracts extends Contract[], Result extends any[] = [], Depth extends ReadonlyArray<number> = []> = Depth['length'] extends MAXIMUM_DEPTH ? GetReturnType[] : TContracts extends [] ? [] : TContracts extends [infer Head extends Contract] ? [...Result, GetReturnType<Head['abi'], Head['functionName']>] : TContracts extends [
+    infer Head extends Contract,
+    ...infer Tail extends Contract[]
+] ? ContractsResult<[
+    ...Tail
+], [
+    ...Result,
+    GetReturnType<Head['abi'], Head['functionName']>
+], [
+    ...Depth,
+    1
+]> : TContracts extends GetConfig<infer TAbi, infer TFunctionName>[] ? GetReturnType<TAbi, TFunctionName>[] : GetReturnType[];
+/**
+ * Get name for {@link AbiFunction} or {@link AbiEvent}
+ *
+ * @param TAbiItem - {@link AbiFunction} or {@link AbiEvent}
+ * @param IsSignature - Whether to return the signature instead of the name
+ * @returns Name or signature of function or event
+ *
+ * @example
+ * type Result = AbiItemName<{ type: 'function'; name: 'Foo'; … }>
+ */
+type AbiItemName<TAbiItem extends (AbiFunction & {
+    type: 'function';
+}) | AbiEvent, IsSignature extends boolean = false> = IsSignature extends true ? TAbiItem['inputs'] extends infer TAbiParameters extends readonly AbiParameter[] ? `${TAbiItem['name']}(${Join<[
+    ...{
+        [K in keyof TAbiParameters]: TAbiParameters[K]['type'];
+    }
+], ','>})` : never : TAbiItem['name'];
+/**
+ * Get overrides for {@link AbiStateMutability}
+ *
+ * @param TAbiStateMutability - {@link AbiStateMutability}
+ * @returns Overrides for {@link TAbiStateMutability}
+ *
+ * @example
+ * type Result = GetOverridesForAbiStateMutability<'pure'>
+ */
+type GetOverridesForAbiStateMutability<TAbiStateMutability extends AbiStateMutability> = {
+    nonpayable: Overrides & {
+        from?: Address;
+    };
+    payable: PayableOverrides & {
+        from?: Address;
+    };
+    pure: CallOverrides;
+    view: CallOverrides;
+}[TAbiStateMutability];
+interface Overrides extends ethers.Overrides {
+    gasLimit?: ResolvedConfig['BigIntType'];
+    gasPrice?: ResolvedConfig['BigIntType'];
+    maxFeePerGas?: ResolvedConfig['BigIntType'];
+    maxPriorityFeePerGas?: ResolvedConfig['BigIntType'];
+    nonce?: ResolvedConfig['IntType'];
+}
+interface PayableOverrides extends Overrides {
+    value?: ResolvedConfig['IntType'] | ResolvedConfig['BigIntType'];
+}
+interface CallOverrides extends PayableOverrides {
+    blockTag?: ethers.CallOverrides['blockTag'];
+    from?: Address;
+}
+type Event<TAbiEvent extends AbiEvent> = Omit<ethers.Event, 'args' | 'event' | 'eventSignature'> & {
+    args: AbiParametersToPrimitiveTypes<TAbiEvent['inputs']>;
+    event: TAbiEvent['name'];
+    eventSignature: AbiItemName<TAbiEvent, true>;
+};
+
+export { AbiItemName as A, CountOccurrences as C, Event as E, GetConfig as G, IsUnknown as I, UnionToIntersection as U, GetOverridesForAbiStateMutability as a, Contract as b, ContractsConfig as c, ContractsResult as d, GetReturnType as e };

package/dist/index.d.ts

@@ -6,10 +6,10 @@ import { Connector, ConnectorData } from '@wagmi/connectors';
 export { Connector, ConnectorData, ConnectorEvents } from '@wagmi/connectors';
 import { P as Provider, W as WebSocketProvider, U as Unit, S as Signer, H as Hash, C as ChainProviderFn, a as ProviderWithFallbackConfig } from './index-37d6352e.js';
 export { C as ChainProviderFn, E as Ethereum, F as FallbackProviderConfig, H as Hash, P as Provider, a as ProviderWithFallbackConfig, S as Signer, U as Unit, W as WebSocketProvider, u as units } from './index-37d6352e.js';
-import { Address, ResolvedConfig, TypedDataDomain, Narrow, TypedData, TypedDataToPrimitiveTypes, Abi, ExtractAbiFunction, ExtractAbiEventNames, AbiParametersToPrimitiveTypes, ExtractAbiEvent, AbiFunction, AbiParameter, AbiParameterToPrimitiveType, AbiEvent, ExtractAbiFunctionNames } from 'abitype';
+import { Address, ResolvedConfig, TypedData, TypedDataToPrimitiveTypes, TypedDataDomain, Narrow, Abi, ExtractAbiFunction, ExtractAbiEventNames, AbiParametersToPrimitiveTypes, ExtractAbiEvent, AbiFunction, AbiParameter, AbiParameterToPrimitiveType, AbiEvent, ExtractAbiFunctionNames } from 'abitype';
 export { Address } from 'abitype';
-import { PopulatedTransaction, Signer as Signer$1, providers, Contract as Contract$1, ethers, ContractInterface } from 'ethers';
-import { O as Options$2, D as DefaultOptions, G as GetConfig$1, a as GetOverridesForAbiStateMutability, U as UnionToIntersection, C as CountOccurrences, A as AbiItemName, I as IsUnknown, E as Event, b as ContractsConfig, c as ContractsResult, d as GetReturnType, e as Or, f as IsNever, N as NotEqual } from './contracts-3880ee54.js';
+import { PopulatedTransaction, Signer as Signer$1, providers, Contract as Contract$1, ethers, Transaction, ContractInterface } from 'ethers';
+import { G as GetConfig, a as GetOverridesForAbiStateMutability, U as UnionToIntersection, C as CountOccurrences, A as AbiItemName, I as IsUnknown, E as Event, b as Contract$2, c as ContractsConfig, d as ContractsResult, e as GetReturnType } from './contracts-9eb7706c.js';
 import { TransactionResponse } from '@ethersproject/providers';
 export { InjectedConnector, InjectedConnectorOptions } from '@wagmi/connectors/injected';
 import * as abitype_dist_abi_b1bae27f from 'abitype/dist/abi-b1bae27f';
@@ -935,8 +935,8 @@ type GetAccountResult<TProvider extends Provider = Provider> = {
     isReconnecting: true;
     status: 'reconnecting';
 } | {
-    address: undefined;
-    connector: undefined;
+    address: Data$1<TProvider>['account'];
+    connector: Client<TProvider>['connector'];
     isConnected: false;
     isReconnecting: false;
     isConnecting: true;
@@ -968,12 +968,16 @@ type SignMessageArgs = {
 type SignMessageResult = ResolvedConfig['BytesType'];
 declare function signMessage(args: SignMessageArgs): Promise<SignMessageResult>;
 
-type SignTypedDataArgs<TTypedData = unknown> = {
+type SignTypedDataArgs<TTypedData extends TypedData | {
+    [key: string]: unknown;
+} = TypedData, TSchema = TTypedData extends TypedData ? TypedDataToPrimitiveTypes<TTypedData> : {
+    [key: string]: any;
+}, TValue = TSchema[keyof TSchema]> = {
     /** Domain or domain signature for origin or contract */
     domain: TypedDataDomain;
     /** Named list of all type definitions */
     types: Narrow<TTypedData>;
-} & (TTypedData extends TypedData ? TypedDataToPrimitiveTypes<TTypedData> extends infer TSchema ? TSchema[keyof TSchema] extends infer TValue ? {
+} & ({
     [key: string]: any;
 } extends TValue ? {
     /**
@@ -987,7 +991,7 @@ type SignTypedDataArgs<TTypedData = unknown> = {
 } : {
     /** Data to sign */
     value: TValue;
-} : never : never : never);
+});
 type SignTypedDataResult = string;
 declare function signTypedData<TTypedData extends TypedData>({ domain, types, value, }: SignTypedDataArgs<TTypedData>): Promise<SignTypedDataResult>;
 
@@ -1040,9 +1044,8 @@ type FetchTokenResult = {
 };
 declare function fetchToken({ address, chainId, formatUnits: units, }: FetchTokenArgs): Promise<FetchTokenResult>;
 
-type PrepareWriteContractConfig<TAbi = Abi, TFunctionName = string, TSigner extends Signer = Signer, TOptions extends Options$2 = DefaultOptions> = GetConfig$1<{
-    abi: TAbi;
-    functionName: TFunctionName;
+type StateMutability$1 = 'nonpayable' | 'payable';
+type PrepareWriteContractConfig<TAbi extends Abi | readonly unknown[] = Abi, TFunctionName extends string = string, TSigner extends Signer = Signer> = GetConfig<TAbi, TFunctionName, StateMutability$1> & {
     /** Chain id to use for provider */
     chainId?: number;
     /** Overrides */
@@ -1052,20 +1055,21 @@ type PrepareWriteContractConfig<TAbi = Abi, TFunctionName = string, TSigner exte
     ] extends [
         infer TAbi_ extends Abi,
         infer TFunctionName_ extends string
-    ] ? ExtractAbiFunction<TAbi_, TFunctionName_>['stateMutability'] : 'nonpayable' | 'payable'>;
+    ] ? ExtractAbiFunction<TAbi_, TFunctionName_>['stateMutability'] : StateMutability$1>;
     /** Custom signer */
     signer?: TSigner | null;
-}, 'nonpayable' | 'payable', TOptions>;
-type PrepareWriteContractResult<TAbi = Abi, TFunctionName extends string = string> = {
+};
+type Request$1 = PopulatedTransaction & {
+    to: Address;
+    gasLimit: NonNullable<PopulatedTransaction['gasLimit']>;
+};
+type PrepareWriteContractResult<TAbi extends Abi | readonly unknown[] = Abi, TFunctionName extends string = string> = {
     abi: TAbi extends Abi ? [ExtractAbiFunction<TAbi, TFunctionName>] : TAbi;
-    address: string;
+    address: Address;
     chainId?: number;
     functionName: TFunctionName;
     mode: 'prepared';
-    request: PopulatedTransaction & {
-        to: Address;
-        gasLimit: NonNullable<PopulatedTransaction['gasLimit']>;
-    };
+    request: Request$1;
 };
 /**
  * @description Prepares the parameters required for a contract write transaction.
@@ -1082,7 +1086,7 @@ type PrepareWriteContractResult<TAbi = Abi, TFunctionName extends string = strin
  * })
  * const result = await writeContract(config)
  */
-declare function prepareWriteContract<TAbi extends Abi | readonly unknown[], TFunctionName extends string, TSigner extends Signer = Signer>({ abi, address, args, chainId, functionName, overrides, signer: signer_, }: PrepareWriteContractConfig<TAbi, TFunctionName, TSigner>): Promise<PrepareWriteContractResult<TAbi, TFunctionName>>;
+declare function prepareWriteContract<TAbi extends Abi | readonly unknown[], TFunctionName extends string, TSigner extends Signer = Signer>({ abi, address, chainId, functionName, overrides, signer: signer_, ...config }: PrepareWriteContractConfig<TAbi, TFunctionName, TSigner>): Promise<PrepareWriteContractResult<TAbi, TFunctionName>>;
 
 type GetContractArgs<TAbi extends Abi | readonly unknown[] = Abi> = {
     /** Contract address */
@@ -1195,7 +1199,7 @@ type Filters<TAbi extends Abi> = UnionToIntersection<{
     } : never;
 }[number]>;
 
-type MulticallConfig<TContracts extends unknown[]> = {
+type MulticallConfig<TContracts extends Contract$2[]> = {
     /** Failures in the multicall will fail silently */
     allowFailure?: boolean;
     /** Chain id to use for provider */
@@ -1203,83 +1207,64 @@ type MulticallConfig<TContracts extends unknown[]> = {
     /** Contracts to query */
     contracts: readonly [...ContractsConfig<TContracts>];
     /** Call overrides */
-    overrides?: GetOverridesForAbiStateMutability<'pure'> | GetOverridesForAbiStateMutability<'view'>;
+    overrides?: GetOverridesForAbiStateMutability<'pure' | 'view'>;
 };
-type MulticallResult<TContracts extends unknown[]> = ContractsResult<TContracts>;
+type MulticallResult<TContracts extends Contract$2[]> = ContractsResult<TContracts>;
 declare function multicall<TAbi extends Abi | readonly unknown[], TFunctionName extends string, TContracts extends {
     abi: TAbi;
     functionName: TFunctionName;
 }[]>({ allowFailure, chainId, contracts, overrides, }: MulticallConfig<TContracts>): Promise<MulticallResult<TContracts>>;
 
-type ReadContractConfig<TAbi = Abi, TFunctionName = string, TOptions extends Options$2 = DefaultOptions> = GetConfig$1<{
-    abi: TAbi;
-    functionName: TFunctionName;
+type StateMutability = 'pure' | 'view';
+type ReadContractConfig<TAbi extends Abi | readonly unknown[] = Abi, TFunctionName extends string = string> = GetConfig<TAbi, TFunctionName, StateMutability> & {
     /** Chain id to use for provider */
     chainId?: number;
     /** Call overrides */
-    overrides?: GetOverridesForAbiStateMutability<'pure' | 'view'>;
-}, 'pure' | 'view', TOptions>;
-type ReadContractResult<TAbi = Abi, TFunctionName = string> = GetReturnType<{
-    abi: TAbi;
-    functionName: TFunctionName;
-}>;
-declare function readContract<TAbi extends Abi | readonly unknown[], TFunctionName extends string>({ address, args, chainId, abi, functionName, overrides, }: ReadContractConfig<TAbi, TFunctionName>): Promise<ReadContractResult<TAbi, TFunctionName>>;
-
-type Options$1 = Options$2 & {
-    isContractsOptional?: boolean;
+    overrides?: GetOverridesForAbiStateMutability<StateMutability>;
 };
-type ReadContractsConfig<TContracts extends unknown[], TOptions extends Options$1 = DefaultOptions, _Contracts = readonly [
-    ...ContractsConfig<TContracts, {
-        /** Chain id to use for provider */
-        chainId?: number;
-    }, TOptions>
-]> = {
+type ReadContractResult<TAbi extends Abi | readonly unknown[] = Abi, TFunctionName extends string = string> = GetReturnType<TAbi, TFunctionName>;
+declare function readContract<TAbi extends Abi | readonly unknown[], TFunctionName extends string>({ address, chainId, abi, functionName, overrides, ...config }: ReadContractConfig<TAbi, TFunctionName>): Promise<ReadContractResult<TAbi, TFunctionName>>;
+
+type ReadContractsConfig<TContracts extends Contract$2[]> = {
     /** Failures in the multicall will fail silently */
     allowFailure?: boolean;
+    /** Contracts to query */
+    contracts: readonly [
+        ...ContractsConfig<TContracts, {
+            /** Chain id to use for provider */
+            chainId?: number;
+        }>
+    ];
     /** Call overrides */
     overrides?: GetOverridesForAbiStateMutability<'pure' | 'view'>;
-} & (TOptions['isContractsOptional'] extends true ? {
-    /** Contracts to query */
-    contracts?: _Contracts;
-} : {
-    /** Contracts to query */
-    contracts: _Contracts;
-});
-type ReadContractsResult<TContracts extends unknown[]> = ContractsResult<TContracts>;
+};
+type ReadContractsResult<TContracts extends Contract$2[]> = ContractsResult<TContracts>;
 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>>;
 
-type ContractEventConfig<TAbi extends Abi | readonly unknown[] = Abi, TEventName extends string = string> = {
-    /** Contract address */
-    address: string;
+type WatchContractEventConfig<TAbi extends Abi | readonly unknown[] = Abi, TEventName extends string = string> = {
     /** Contract ABI */
     abi: Narrow<TAbi>;
+    /** Contract address */
+    address: Address;
     /** Chain id to use for provider */
     chainId?: number;
-    /** Event to listen for */
-    eventName: IsNever<TEventName> extends true ? string : TEventName;
+    /** Function to invoke on the contract */
+    eventName: GetEventName<TAbi, TEventName>;
     /** Receive only a single event */
     once?: boolean;
 };
-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;
-type WatchContractEventConfig<TAbi = Abi, TEventName = string> = GetConfig<{
-    abi: TAbi;
-    eventName: TEventName;
-}>;
-type WatchContractEventCallback<TAbi extends Abi | readonly unknown[] = Abi, TEventName extends string = string, TAbiEvent extends AbiEvent = TAbi extends Abi ? ExtractAbiEvent<TAbi, TEventName> : never> = AbiParametersToPrimitiveTypes<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;
+type WatchContractEventCallback<TAbi extends Abi | readonly unknown[] = Abi, TEventName extends string = string> = GetListener<TAbi, TEventName>;
 declare function watchContractEvent<TAbi extends Abi | readonly unknown[], TEventName extends string>({ address, abi, chainId, eventName, once, }: WatchContractEventConfig<TAbi, TEventName>, callback: WatchContractEventCallback<TAbi, TEventName>): () => void;
+type GetEventName<TAbi extends Abi | readonly unknown[] = Abi, TEventName extends string = string> = TAbi extends Abi ? ExtractAbiEventNames<TAbi> extends infer AbiEventNames ? AbiEventNames | (TEventName extends AbiEventNames ? TEventName : never) | (Abi extends TAbi ? string : never) : never : TEventName;
+type GetListener<TAbi extends Abi | readonly unknown[], TEventName extends string, TAbiEvent extends AbiEvent = TAbi extends Abi ? ExtractAbiEvent<TAbi, TEventName> : AbiEvent, TArgs = AbiParametersToPrimitiveTypes<TAbiEvent['inputs']>, FailedToParseArgs = ([TArgs] extends [never] ? true : false) | (readonly unknown[] extends TArgs ? true : false)> = true extends FailedToParseArgs ? (...args: readonly unknown[]) => void : (...args: TArgs extends readonly unknown[] ? TArgs : readonly unknown[]) => void;
 
-type WatchMulticallConfig<TContracts extends unknown[]> = MulticallConfig<TContracts> & {
+type WatchMulticallConfig<TContracts extends Contract$2[]> = MulticallConfig<TContracts> & {
     listenToBlock?: boolean;
 };
-type WatchMulticallCallback<TContracts extends unknown[]> = (results: MulticallResult<TContracts>) => void;
+type WatchMulticallCallback<TContracts extends Contract$2[]> = (results: MulticallResult<TContracts>) => void;
 declare function watchMulticall<TAbi extends Abi | readonly unknown[], TFunctionName extends string, TContracts extends {
     abi: TAbi;
     functionName: TFunctionName;
@@ -1291,10 +1276,10 @@ type WatchReadContractConfig<TAbi extends Abi | readonly unknown[] = Abi, TFunct
 type WatchReadContractCallback<TAbi extends Abi | readonly unknown[], TFunctionName extends string> = (result: ReadContractResult<TAbi, TFunctionName>) => void;
 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;
 
-type WatchReadContractsConfig<TContracts extends unknown[]> = ReadContractsConfig<TContracts> & {
+type WatchReadContractsConfig<TContracts extends Contract$2[]> = ReadContractsConfig<TContracts> & {
     listenToBlock?: boolean;
 };
-type WatchReadContractsCallback<TContracts extends unknown[]> = (results: ReadContractsResult<TContracts>) => void;
+type WatchReadContractsCallback<TContracts extends Contract$2[]> = (results: ReadContractsResult<TContracts>) => void;
 declare function watchReadContracts<TAbi extends Abi | readonly unknown[], TFunctionName extends string, TContracts extends {
     abi: TAbi;
     functionName: TFunctionName;
@@ -1418,14 +1403,19 @@ type WaitForTransactionArgs = {
 type WaitForTransactionResult = providers.TransactionReceipt;
 declare function waitForTransaction({ chainId, confirmations, hash, onSpeedUp, timeout, }: WaitForTransactionArgs): Promise<WaitForTransactionResult>;
 
-type Options = Options$2 & {
-    isRequestOptional?: boolean;
+type WatchPendingTransactionsResult = Transaction;
+type WatchPendingTransactionsArgs = {
+    chainId?: number;
 };
+type WatchPendingTransactionsCallback = (transaction: WatchPendingTransactionsResult) => void;
+declare function watchPendingTransactions(args: WatchPendingTransactionsArgs, callback: WatchPendingTransactionsCallback): () => void;
+
+type WriteContractMode = 'prepared' | 'recklesslyUnprepared';
 type Request = PopulatedTransaction & {
     to: Address;
     gasLimit: NonNullable<PopulatedTransaction['gasLimit']>;
 };
-type WriteContractPreparedArgs<TOptions extends Options = DefaultOptions> = {
+type WriteContractPreparedArgs<TAbi extends Abi | readonly unknown[], TFunctionName extends string> = {
     /**
      * `recklesslyUnprepared`: Allow to pass through unprepared config. Note: This has
      * [UX pitfalls](https://wagmi.sh/react/prepare-hooks/intro#ux-pitfalls-without-prepare-hooks),
@@ -1436,21 +1426,26 @@ type WriteContractPreparedArgs<TOptions extends Options = DefaultOptions> = {
      * via the {@link prepareWriteContract} function
      * */
     mode: 'prepared';
+    /** Chain id to use for provider */
+    chainId?: number;
+    /** Request to submit transaction for */
+    request: Request;
     args?: never;
     overrides?: never;
-} & (TOptions['isRequestOptional'] extends true ? {
-    /** The prepared request. */
-    request?: Request;
-} : {
-    /** The prepared request. */
-    request: Request;
-});
-type WriteContractUnpreparedArgs<TAbi = Abi, TFunctionName = string, TOptions extends Options = DefaultOptions> = {
+} & Omit<GetConfig<TAbi, TFunctionName, 'nonpayable' | 'payable'>, 'args'>;
+type WriteContractUnpreparedArgs<TAbi extends Abi | readonly unknown[], TFunctionName extends string> = {
+    /**
+     * `recklesslyUnprepared`: Allow to pass through unprepared config. Note: This has
+     * [UX pitfalls](https://wagmi.sh/react/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: 'recklesslyUnprepared';
-    request?: never;
-} & GetConfig$1<{
-    abi: TAbi;
-    functionName: TFunctionName;
+    /** Chain id to use for provider */
+    chainId?: number;
     /** Call overrides */
     overrides?: GetOverridesForAbiStateMutability<[
         TAbi,
@@ -1459,13 +1454,9 @@ type WriteContractUnpreparedArgs<TAbi = Abi, TFunctionName = string, TOptions ex
         infer TAbi_ extends Abi,
         infer TFunctionName_ extends string
     ] ? ExtractAbiFunction<TAbi_, TFunctionName_>['stateMutability'] : 'nonpayable' | 'payable'>;
-}, 'nonpayable' | 'payable', TOptions>;
-type WriteContractArgs<TAbi = Abi, TFunctionName = string, TOptions extends Options = DefaultOptions> = Omit<GetConfig$1<{
-    abi: TAbi;
-    functionName: TFunctionName;
-    /** Chain id to use for provider */
-    chainId?: number;
-}, 'nonpayable' | 'payable', TOptions>, 'args'> & (WriteContractUnpreparedArgs<TAbi, TFunctionName, TOptions> | WriteContractPreparedArgs<TOptions>);
+    request?: never;
+} & GetConfig<TAbi, TFunctionName, 'nonpayable' | 'payable'>;
+type WriteContractArgs<TAbi extends Abi | readonly unknown[], TFunctionName extends string> = WriteContractUnpreparedArgs<TAbi, TFunctionName> | WriteContractPreparedArgs<TAbi, TFunctionName>;
 type WriteContractResult = SendTransactionResult;
 /**
  * @description Function to call a contract write method.
@@ -1762,4 +1753,4 @@ type CircularReplacer = (key: string, value: any, referenceKey: string) => any;
  */
 declare function serialize(value: any, replacer?: StandardReplacer | null | undefined, indent?: number | null | undefined, circularReplacer?: CircularReplacer | null | undefined): string;
 
-export { AddChainError, ChainDoesNotSupportMulticallError, ChainMismatchError, ChainNotConfiguredError, Client, ClientConfig, ConfigureChainsConfig, ConnectArgs, ConnectResult, ConnectorAlreadyConnectedError, ConnectorNotFoundError, ContractMethodDoesNotExistError, ContractMethodNoResultError, ContractMethodRevertedError, ContractResultDecodeError, FetchBalanceArgs, FetchBalanceResult, FetchBlockNumberArgs, FetchBlockNumberResult, FetchEnsAddressArgs, FetchEnsAddressResult, FetchEnsAvatarArgs, FetchEnsAvatarResult, FetchEnsNameArgs, FetchEnsNameResult, FetchEnsResolverArgs, FetchEnsResolverResult, FetchFeeDataArgs, FetchFeeDataResult, FetchSignerArgs, FetchSignerResult, FetchTokenArgs, FetchTokenResult, FetchTransactionArgs, FetchTransactionResult, GetAccountResult, GetContractArgs, GetContractResult, GetNetworkResult, GetProviderArgs, GetProviderResult, GetWebSocketProviderArgs, GetWebSocketProviderResult, MulticallConfig, MulticallResult, PrepareSendTransactionArgs, PrepareSendTransactionResult, PrepareWriteContractConfig, PrepareWriteContractResult, ProviderChainsNotFound, ProviderRpcError, ReadContractConfig, ReadContractResult, ReadContractsConfig, ReadContractsResult, ResourceUnavailableError, RpcError, SendTransactionArgs, SendTransactionPreparedRequest, SendTransactionResult, SendTransactionUnpreparedRequest, SignMessageArgs, SignMessageResult, SignTypedDataArgs, SignTypedDataResult, ClientStorage as Storage, SwitchChainError, SwitchChainNotSupportedError, SwitchNetworkArgs, SwitchNetworkResult, UserRejectedRequestError, WaitForTransactionArgs, WaitForTransactionResult, WatchAccountCallback, WatchBlockNumberArgs, WatchBlockNumberCallback, WatchMulticallCallback, WatchMulticallConfig, WatchNetworkCallback, WatchProviderCallback, WatchReadContractCallback, WatchReadContractConfig, WatchReadContractsCallback, WatchReadContractsConfig, WatchSignerCallback, WatchWebSocketProviderCallback, WriteContractArgs, WriteContractPreparedArgs, WriteContractResult, WriteContractUnpreparedArgs, configureChains, connect, createClient, createStorage, deepEqual, deserialize, disconnect, erc20ABI, erc4626ABI, erc721ABI, fetchBalance, fetchBlockNumber, fetchEnsAddress, fetchEnsAvatar, fetchEnsName, fetchEnsResolver, fetchFeeData, fetchSigner, fetchToken, fetchTransaction, getAccount, getClient, getContract, getNetwork, getProvider, getWebSocketProvider, minimizeContractInterface, multicall, noopStorage, normalizeChainId, parseContractResult, prepareSendTransaction, prepareWriteContract, readContract, readContracts, sendTransaction, serialize, signMessage, signTypedData, switchNetwork, waitForTransaction, watchAccount, watchBlockNumber, watchContractEvent, watchMulticall, watchNetwork, watchProvider, watchReadContract, watchReadContracts, watchSigner, watchWebSocketProvider, writeContract };
+export { AddChainError, ChainDoesNotSupportMulticallError, ChainMismatchError, ChainNotConfiguredError, Client, ClientConfig, ConfigureChainsConfig, ConnectArgs, ConnectResult, ConnectorAlreadyConnectedError, ConnectorNotFoundError, ContractMethodDoesNotExistError, ContractMethodNoResultError, ContractMethodRevertedError, ContractResultDecodeError, FetchBalanceArgs, FetchBalanceResult, FetchBlockNumberArgs, FetchBlockNumberResult, FetchEnsAddressArgs, FetchEnsAddressResult, FetchEnsAvatarArgs, FetchEnsAvatarResult, FetchEnsNameArgs, FetchEnsNameResult, FetchEnsResolverArgs, FetchEnsResolverResult, FetchFeeDataArgs, FetchFeeDataResult, FetchSignerArgs, FetchSignerResult, FetchTokenArgs, FetchTokenResult, FetchTransactionArgs, FetchTransactionResult, GetAccountResult, GetContractArgs, GetContractResult, GetNetworkResult, GetProviderArgs, GetProviderResult, GetWebSocketProviderArgs, GetWebSocketProviderResult, MulticallConfig, MulticallResult, PrepareSendTransactionArgs, PrepareSendTransactionResult, PrepareWriteContractConfig, PrepareWriteContractResult, ProviderChainsNotFound, ProviderRpcError, ReadContractConfig, ReadContractResult, ReadContractsConfig, ReadContractsResult, ResourceUnavailableError, RpcError, SendTransactionArgs, SendTransactionPreparedRequest, SendTransactionResult, SendTransactionUnpreparedRequest, SignMessageArgs, SignMessageResult, SignTypedDataArgs, SignTypedDataResult, ClientStorage as Storage, SwitchChainError, SwitchChainNotSupportedError, SwitchNetworkArgs, SwitchNetworkResult, UserRejectedRequestError, WaitForTransactionArgs, WaitForTransactionResult, WatchAccountCallback, WatchBlockNumberArgs, WatchBlockNumberCallback, WatchContractEventCallback, WatchContractEventConfig, WatchMulticallCallback, WatchMulticallConfig, WatchNetworkCallback, WatchPendingTransactionsArgs, WatchPendingTransactionsCallback, WatchPendingTransactionsResult, WatchProviderCallback, WatchReadContractCallback, WatchReadContractConfig, WatchReadContractsCallback, WatchReadContractsConfig, WatchSignerCallback, WatchWebSocketProviderCallback, WriteContractArgs, WriteContractMode, WriteContractPreparedArgs, WriteContractResult, WriteContractUnpreparedArgs, configureChains, connect, createClient, createStorage, deepEqual, deserialize, disconnect, erc20ABI, erc4626ABI, erc721ABI, fetchBalance, fetchBlockNumber, fetchEnsAddress, fetchEnsAvatar, fetchEnsName, fetchEnsResolver, fetchFeeData, fetchSigner, fetchToken, fetchTransaction, getAccount, getClient, getContract, getNetwork, getProvider, getWebSocketProvider, minimizeContractInterface, multicall, noopStorage, normalizeChainId, parseContractResult, prepareSendTransaction, prepareWriteContract, readContract, readContracts, sendTransaction, serialize, signMessage, signTypedData, switchNetwork, waitForTransaction, watchAccount, watchBlockNumber, watchContractEvent, watchMulticall, watchNetwork, watchPendingTransactions, watchProvider, watchReadContract, watchReadContracts, watchSigner, watchWebSocketProvider, writeContract };

package/dist/index.js

@@ -65,13 +65,14 @@ import {
   watchContractEvent,
   watchMulticall,
   watchNetwork,
+  watchPendingTransactions,
   watchProvider,
   watchReadContract,
   watchReadContracts,
   watchSigner,
   watchWebSocketProvider,
   writeContract
-} from "./chunk-DYHSCPJD.js";
+} from "./chunk-VRBYTA34.js";
 import {
   goerli,
   mainnet
@@ -153,6 +154,7 @@ export {
   watchContractEvent,
   watchMulticall,
   watchNetwork,
+  watchPendingTransactions,
   watchProvider,
   watchReadContract,
   watchReadContracts,

package/dist/internal/index.d.ts

@@ -1,4 +1,4 @@
-export { g as AbiParameter, h as ContractConfig, b as ContractsConfig, c as ContractsResult, E as Event, i as GetArgs, G as GetConfig, d as GetReturnType, f as IsNever, N as NotEqual, j as Optional, e as Or } from '../contracts-3880ee54.js';
+export { b as Contract, c as ContractsConfig } from '../contracts-9eb7706c.js';
 import '../index-37d6352e.js';
 import 'abitype';
 import 'ethers';

package/dist/internal/index.js

@@ -1,6 +1,6 @@
 import {
   debounce
-} from "../chunk-DYHSCPJD.js";
+} from "../chunk-VRBYTA34.js";
 import "../chunk-BVC4KGLQ.js";
 import "../chunk-MQXBDTVK.js";
 export {

package/dist/internal/test.js

@@ -1,5 +1,5 @@
 import "../chunk-KX4UEHS5.js";
-import "../chunk-DYHSCPJD.js";
+import "../chunk-VRBYTA34.js";
 import {
   foundry,
   goerli,

package/package.json

@@ -2,7 +2,7 @@
   "name": "@wagmi/core",
   "description": "Vanilla JS library for Ethereum",
   "license": "MIT",
-  "version": "0.8.6",
+  "version": "0.8.8",
   "repository": {
     "type": "git",
     "url": "https://github.com/wagmi-dev/wagmi.git",
@@ -115,7 +115,7 @@
     "eventemitter3": "^4.0.7",
     "zustand": "^4.1.4",
     "@wagmi/chains": "0.1.7",
-    "@wagmi/connectors": "0.1.2"
+    "@wagmi/connectors": "0.1.3"
   },
   "devDependencies": {
     "@coinbase/wallet-sdk": "^3.6.0",

package/dist/contracts-3880ee54.d.ts

@@ -1,334 +0,0 @@
-import { AbiParameter as AbiParameter$1, Abi, AbiFunction, AbiParametersToPrimitiveTypes, ExtractAbiFunction, Narrow, AbiStateMutability, ExtractAbiFunctionNames, AbiEvent, AbiParameterToPrimitiveType, Address, ResolvedConfig } from 'abitype';
-import { ethers } from 'ethers';
-
-/**
- * Count occurrences of {@link TType} in {@link TArray}
- *
- * @param TArray - Array to count occurrences in
- * @param TType - Type to count occurrences of
- * @returns Number of occurrences of {@link TType} in {@link TArray}
- *
- * @example
- * type Result = CountOccurrences<['foo', 'bar', 'foo'], 'foo'>
- */
-type CountOccurrences<TArray extends readonly unknown[], TType> = FilterNever<[
-    ...{
-        [K in keyof TArray]: TArray[K] extends TType ? TArray[K] : never;
-    }
-]>['length'];
-/**
- * Removes all occurrences of `never` from {@link TArray}
- *
- * @param TArray - Array to filter
- * @returns Array with `never` removed
- *
- * @example
- * type Result = FilterNever<[1, 2, never, 3, never, 4]>
- */
-type FilterNever<TArray extends readonly unknown[]> = TArray['length'] extends 0 ? [] : TArray extends [infer THead, ...infer TRest] ? IsNever<THead> extends true ? FilterNever<TRest> : [THead, ...FilterNever<TRest>] : never;
-/**
- * Check if {@link T} is `never`
- *
- * @param T - Type to check
- * @returns `true` if {@link T} is `never`, otherwise `false`
- *
- * @example
- * type Result = IsNever<'foo'>
- */
-type IsNever<T> = [T] extends [never] ? true : false;
-/**
- * Checks if {@link T} is `unknown`
- *
- * @param T - Type to check
- * @returns `true` if {@link T} is `unknown`, otherwise `false`
- *
- * @example
- * type Result = IsUnknown<unknown>
- */
-type IsUnknown<T> = unknown extends T ? true : false;
-/**
- * Joins {@link Items} into string separated by {@link Separator}
- *
- * @param Items - Items to join
- * @param Separator - Separator to use
- * @returns Joined string
- *
- * @example
- * type Result = Join<['foo', 'bar'], '-'>
- */
-type Join<Items extends string[], Separator extends string | number> = Items extends [infer First, ...infer Rest] ? First extends string ? Rest extends string[] ? Rest extends [] ? `${First}` : `${First}${Separator}${Join<Rest, Separator>}` : never : never : '';
-/**
- * Check if {@link T} and {@link U} are equal
- *
- * @param T
- * @param U
- * @returns `true` if {@link T} and {@link U} are not equal, otherwise `false`
- *
- * @example
- * type Result = NotEqual<'foo', 'bar'>
- */
-type NotEqual<T, U> = [T] extends [U] ? false : true;
-/**
- * Convert {@link TKeys} of {@link TObject} to optional properties
- *
- * @param TObject
- * @param TKeys
- * @returns {@link TObject} with {@link TKeys} converted to optional properties
- *
- * @example
- * type Result = Optional<{ foo: string; bar: number }, 'foo'>
- */
-type Optional<TObject, TKeys extends keyof TObject> = {
-    [K in keyof TObject as K extends TKeys ? never : K]: TObject[K];
-} & {
-    [K in keyof TObject as K extends TKeys ? K : never]?: TObject[K];
-};
-/**
- * Boolean "or" operator
- *
- * @param T
- * @param U
- * @returns `true` if either {@link T} or {@link U} are `true`, otherwise `false`
- *
- * @example
- * type Result = Or<true, false>
- */
-type Or<T, U> = T extends true ? true : U extends true ? true : false;
-/**
- * Converts {@link Union} to intersection
- *
- * @param Union - Union to convert
- * @returns Intersection of {@link Union}
- *
- * @example
- * type Result = UnionToIntersection<'foo' | 'bar'>
- */
-type UnionToIntersection<Union> = (Union extends unknown ? (arg: Union) => unknown : never) extends (arg: infer R) => unknown ? R : never;
-
-type AbiParameter = AbiParameter$1;
-/**
- * Configuration options for contract types
- */
-type Options = {
-    /** Flag for making `abi` optional */
-    isAbiOptional?: boolean;
-    /** Flag for making `address` optional */
-    isAddressOptional?: boolean;
-    /** Flag for making `args` optional */
-    isArgsOptional?: boolean;
-    /** Flag for making `functionName` optional */
-    isFunctionNameOptional?: boolean;
-};
-/**
- * Default {@link Options}
- */
-type DefaultOptions = {
-    isAbiOptional: false;
-    isAddressOptional: false;
-    isArgsOptional: false;
-    isFunctionNameOptional: false;
-};
-/**
- * Gets arguments of contract function
- *
- * @param TAbi - Contract {@link Abi}
- * @param TFunctionName - Name of contract function
- * @param TOptions - Options for configuring arguments. Defaults to {@link DefaultOptions}.
- * @returns Inferred args of contract function
- *
- * @example
- * type Result = GetArgs<[…], 'tokenURI'>
- */
-type GetArgs<TAbi extends Abi | readonly unknown[], TFunction extends AbiFunction & {
-    type: 'function';
-}, TOptions extends Options = DefaultOptions> = TFunction['inputs'] extends infer TInputs extends readonly AbiParameter[] ? Or<IsNever<TInputs>, NotEqual<TAbi, Abi>> extends true ? {
-    /**
-     * Arguments to pass contract method
-     *
-     * Use a [const assertion](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-4.html#const-assertions) on {@link abi} for type inference.
-     */
-    args?: readonly unknown[];
-} : TInputs['length'] extends 0 ? {
-    args?: never;
-} : AbiParametersToPrimitiveTypes<TInputs> extends infer TArgs ? TOptions['isArgsOptional'] extends true ? {
-    /** Arguments to pass contract method */
-    args?: TArgs;
-} : {
-    /** Arguments to pass contract method */
-    args: TArgs;
-} : never : never;
-/**
- * Contract configuration object for inferring function name and arguments based on {@link TAbi}.
- */
-type ContractConfig<TContract = {
-    [key: string]: unknown;
-}, TAbi extends Abi | readonly unknown[] = Abi, TFunctionName extends string = string, TFunction extends AbiFunction & {
-    type: 'function';
-} = TAbi extends Abi ? ExtractAbiFunction<TAbi, TFunctionName> : never, TOptions extends Options = DefaultOptions> = (TOptions['isAbiOptional'] extends true ? {
-    /** Contract ABI */
-    abi?: Narrow<TAbi>;
-} : {
-    /** Contract ABI */
-    abi: Narrow<TAbi>;
-}) & (TOptions['isAddressOptional'] extends true ? {
-    /** Contract address */
-    address?: string;
-} : {
-    /** Contract address */
-    address: string;
-}) & (TOptions['isFunctionNameOptional'] extends true ? {
-    /** Function to invoke on the contract */
-    functionName?: IsNever<TFunctionName> extends true ? string : TFunctionName;
-} : {
-    /** Function to invoke on the contract */
-    functionName: IsNever<TFunctionName> extends true ? string : TFunctionName;
-}) & GetArgs<TAbi, TFunction, TOptions> & TContract;
-type OmitConfigProperties = 'abi' | 'args' | 'functionName';
-/**
- * Gets configuration type of contract function
- *
- * @param TContract - Contract config in `{ abi: Abi, functionName: string }` format
- * @param TAbiStateMutibility - State mutability of contract function
- * @param TOptions - Options for configuring arguments. Defaults to {@link DefaultOptions}.
- * @returns Inferred configuration type of contract function
- *
- * @example
- * type Result = GetConfig<{ abi: […], functionName: 'tokenURI' }, 'view'>
- */
-type GetConfig<TContract = unknown, TAbiStateMutibility extends AbiStateMutability = AbiStateMutability, TOptions extends Options = DefaultOptions> = TContract extends {
-    abi: infer TAbi extends Abi;
-    functionName: infer TFunctionName extends string;
-} ? ContractConfig<Omit<TContract, OmitConfigProperties>, TAbi, ExtractAbiFunctionNames<TAbi, TAbiStateMutibility>, ExtractAbiFunction<TAbi, TFunctionName>, TOptions> : TContract extends {
-    abi: infer TAbi extends readonly unknown[];
-    functionName: infer TFunctionName extends string;
-} ? ContractConfig<Omit<TContract, OmitConfigProperties>, TAbi, TFunctionName, never, TOptions> : ContractConfig<Omit<TContract, OmitConfigProperties>, Abi, string, never, TOptions>;
-/**
- * Unwraps return type of contract function
- *
- * @param TAbi - Contract {@link Abi}
- * @param TFunctionName - Name of contract function
- * @returns Inferred return type of contract function
- *
- * @example
- * type Result = GetResult<[…], 'tokenURI'>
- */
-type GetResult<TAbi extends Abi | readonly unknown[] = Abi, TFunctionName extends string = string, TFunction extends AbiFunction & {
-    type: 'function';
-} = TAbi extends Abi ? ExtractAbiFunction<TAbi, TFunctionName> : never> = TFunction['outputs'] extends infer TOutputs extends readonly AbiParameter[] ? Or<IsNever<TOutputs>, NotEqual<TAbi, Abi>> extends true ? unknown : TOutputs['length'] extends infer TLength ? TLength extends 0 ? void : TLength extends 1 ? AbiParameterToPrimitiveType<TOutputs[0]> : TOutputs extends readonly [...infer _] ? /**
-   * Return output as array assigned to an object with named keys
-   *
-   * | Outputs                                                               | Result                                                     |
-   * | --------------------------------------------------------------------- | ---------------------------------------------------------- |
-   * | `[{ name: 'foo', type: 'uint256' }, { name: 'bar', type: 'string' }]` | `readonly [bigint, string] & { foo: bigint; bar: string }` |
-   * | `[{ name: 'foo', type: 'uint256' }, { name: '', type: 'string' }]`    | `readonly [bigint, string] & { foo: bigint }`              |
-   */ {
-    [Output in TOutputs[number] as Output extends {
-        name: string;
-    } ? Output['name'] extends '' ? never : Output['name'] : never]: AbiParameterToPrimitiveType<Output>;
-} & AbiParametersToPrimitiveTypes<TOutputs> : unknown : never : never;
-/**
- * Gets return type of contract function
- *
- * @param TContract - Contract config in `{ abi: Abi, functionName: string }` format
- * @returns Inferred return type of contract function
- *
- * @example
- * type Result = GetReturnType<{ abi: […], functionName: 'tokenURI' }>
- */
-type GetReturnType<TContract = unknown> = TContract extends {
-    abi: infer TAbi extends Abi;
-    functionName: infer TFunctionName extends string;
-} ? GetResult<TAbi, TFunctionName, ExtractAbiFunction<TAbi, TFunctionName>> : TContract extends {
-    abi: infer TAbi extends readonly unknown[];
-    functionName: infer TFunctionName extends string;
-} ? GetResult<TAbi, TFunctionName> : GetResult;
-type MAXIMUM_DEPTH = 20;
-/**
- * ContractsConfig reducer recursively unwraps function arguments to infer/enforce type param
- *
- * @param TContracts - Array of contracts in shape of {@link ContractConfig}
- * @returns Array of inferred contract configurations
- */
-type ContractsConfig<TContracts extends unknown[], TContractProperties extends {
-    [key: string]: unknown;
-} = {
-    [key: string]: unknown;
-}, TOptions extends Options = DefaultOptions, Result extends any[] = [], Depth extends ReadonlyArray<number> = []> = Depth['length'] extends MAXIMUM_DEPTH ? GetConfig<TContractProperties, 'pure' | 'view', TOptions>[] : TContracts extends [] ? [] : TContracts extends [infer Head] ? [
-    ...Result,
-    GetConfig<Head & TContractProperties, 'pure' | 'view', TOptions>
-] : TContracts extends [infer Head, ...infer Tail] ? ContractsConfig<[
-    ...Tail
-], TContractProperties, TOptions, [
-    ...Result,
-    GetConfig<Head & TContractProperties, 'pure' | 'view', TOptions>
-], [
-    ...Depth,
-    1
-]> : unknown[] extends TContracts ? TContracts : TContracts extends ContractConfig<infer TContract, infer TAbi, infer TFunctionName, infer TFunction>[] ? ContractConfig<Omit<TContract & TContractProperties, OmitConfigProperties>, TAbi, TFunctionName, TFunction, TOptions>[] : GetConfig<TContractProperties, 'pure' | 'view', TOptions>[];
-/**
- * ContractsResult reducer recursively maps type param to results
- *
- * @param TContracts - Array of contracts in shape of {@link ContractConfig}
- * @returns Array of inferred contract results
- */
-type ContractsResult<TContracts extends unknown[], Result extends any[] = [], Depth extends ReadonlyArray<number> = []> = Depth['length'] extends MAXIMUM_DEPTH ? GetReturnType[] : TContracts extends [] ? [] : TContracts extends [infer Head] ? [...Result, GetReturnType<Head>] : TContracts extends [infer Head, ...infer Tail] ? ContractsResult<[...Tail], [...Result, GetReturnType<Head>], [...Depth, 1]> : TContracts extends ContractConfig<infer _TContract, infer TAbi, infer TFunctionName>[] ? GetReturnType<{
-    abi: TAbi;
-    functionName: TFunctionName;
-}>[] : GetReturnType[];
-/**
- * Get name for {@link AbiFunction} or {@link AbiEvent}
- *
- * @param TAbiItem - {@link AbiFunction} or {@link AbiEvent}
- * @param IsSignature - Whether to return the signature instead of the name
- * @returns Name or signature of function or event
- *
- * @example
- * type Result = AbiItemName<{ type: 'function'; name: 'Foo'; … }>
- */
-type AbiItemName<TAbiItem extends (AbiFunction & {
-    type: 'function';
-}) | AbiEvent, IsSignature extends boolean = false> = IsSignature extends true ? TAbiItem['inputs'] extends infer TAbiParameters extends readonly AbiParameter[] ? `${TAbiItem['name']}(${Join<[
-    ...{
-        [K in keyof TAbiParameters]: TAbiParameters[K]['type'];
-    }
-], ','>})` : never : TAbiItem['name'];
-/**
- * Get overrides for {@link AbiStateMutability}
- *
- * @param TAbiStateMutability - {@link AbiStateMutability}
- * @returns Overrides for {@link TAbiStateMutability}
- *
- * @example
- * type Result = GetOverridesForAbiStateMutability<'pure'>
- */
-type GetOverridesForAbiStateMutability<TAbiStateMutability extends AbiStateMutability> = {
-    nonpayable: Overrides & {
-        from?: Address;
-    };
-    payable: PayableOverrides & {
-        from?: Address;
-    };
-    pure: CallOverrides;
-    view: CallOverrides;
-}[TAbiStateMutability];
-interface Overrides extends ethers.Overrides {
-    gasLimit?: ResolvedConfig['BigIntType'];
-    gasPrice?: ResolvedConfig['BigIntType'];
-    maxFeePerGas?: ResolvedConfig['BigIntType'];
-    maxPriorityFeePerGas?: ResolvedConfig['BigIntType'];
-    nonce?: ResolvedConfig['IntType'];
-}
-interface PayableOverrides extends Overrides {
-    value?: ResolvedConfig['IntType'] | ResolvedConfig['BigIntType'];
-}
-interface CallOverrides extends PayableOverrides {
-    blockTag?: ethers.CallOverrides['blockTag'];
-    from?: Address;
-}
-type Event<TAbiEvent extends AbiEvent> = Omit<ethers.Event, 'args' | 'event' | 'eventSignature'> & {
-    args: AbiParametersToPrimitiveTypes<TAbiEvent['inputs']>;
-    event: TAbiEvent['name'];
-    eventSignature: AbiItemName<TAbiEvent, true>;
-};
-
-export { AbiItemName as A, CountOccurrences as C, DefaultOptions as D, Event as E, GetConfig as G, IsUnknown as I, NotEqual as N, Options as O, UnionToIntersection as U, GetOverridesForAbiStateMutability as a, ContractsConfig as b, ContractsResult as c, GetReturnType as d, Or as e, IsNever as f, AbiParameter as g, ContractConfig as h, GetArgs as i, Optional as j };