@wagmi/core 0.5.8 → 0.6.1

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

@@ -0,0 +1,241 @@
+import { Abi, AbiEvent, AbiFunction, AbiParameter, AbiParameterToPrimitiveType, AbiParametersToPrimitiveTypes, AbiStateMutability, Address, ExtractAbiFunction, ExtractAbiFunctionNames, Narrow, ResolvedConfig } from 'abitype';
+import { ethers } from 'ethers';
+import { IsNever, Join, NotEqual, Or } from './utils';
+/**
+ * Configuration options for contract types
+ */
+export declare 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}
+ */
+export declare 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'>
+ */
+export declare 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}.
+ */
+export declare 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;
+declare 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'>
+ */
+export declare 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'>
+ */
+declare 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['name'] extends '' ? never : Output['name']]: 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' }>
+ */
+export declare 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;
+declare 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
+ */
+export declare 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
+ */
+export declare 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[];
+/**
+ * Converts array of {@link AbiEvent} parameters to corresponding TypeScript primitive types.
+ *
+ * @param TAbiEventParameters - Array of {@link AbiEvent} parameters to convert to TypeScript representations
+ * @returns Array of TypeScript primitive types
+ */
+export declare type AbiEventParametersToPrimitiveTypes<TAbiEventParameters extends readonly (AbiParameter & {
+    indexed?: boolean;
+})[], Options extends {
+    AllowNull: boolean;
+} = {
+    AllowNull: false;
+}> = {
+    [K in keyof TAbiEventParameters]: TAbiEventParameters[K]['indexed'] extends true ? AbiParameterToPrimitiveType<TAbiEventParameters[K]> | (Options['AllowNull'] extends true ? null : never) : null;
+};
+/**
+ * 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'; … }>
+ */
+export declare 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'>
+ */
+export declare type GetOverridesForAbiStateMutability<TAbiStateMutability extends AbiStateMutability> = {
+    nonpayable: Overrides & {
+        from?: Address;
+    };
+    payable: PayableOverrides & {
+        from?: Address;
+    };
+    pure: CallOverrides;
+    view: CallOverrides;
+}[TAbiStateMutability];
+export interface Overrides extends ethers.Overrides {
+    gasLimit?: ResolvedConfig['BigIntType'];
+    gasPrice?: ResolvedConfig['BigIntType'];
+    maxFeePerGas?: ResolvedConfig['BigIntType'];
+    maxPriorityFeePerGas?: ResolvedConfig['BigIntType'];
+    nonce?: ResolvedConfig['IntType'];
+}
+export interface PayableOverrides extends Overrides {
+    value?: ResolvedConfig['IntType'] | ResolvedConfig['BigIntType'];
+}
+export interface CallOverrides extends PayableOverrides {
+    blockTag?: ethers.CallOverrides['blockTag'];
+    from?: Address;
+}
+export declare type Event<TAbiEvent extends AbiEvent> = Omit<ethers.Event, 'args' | 'event' | 'eventSignature'> & {
+    args: AbiEventParametersToPrimitiveTypes<TAbiEvent['inputs']>;
+    event: TAbiEvent['name'];
+    eventSignature: AbiItemName<TAbiEvent, true>;
+};
+export {};

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

@@ -1,6 +1,25 @@
-import { Signer as BaseSigner, providers } from 'ethers';
+import { Address, ResolvedConfig, TypedData, TypedDataDomain, TypedDataToPrimitiveTypes } from 'abitype';
+import { Signer as BaseSigner, BigNumber, providers } from 'ethers';
 import { BlockExplorer, BlockExplorerName, RpcProviderName, units } from '../constants';
-export declare type Address = `0x${string}`;
+declare module 'abitype' {
+    interface Config {
+        BigIntType: BigNumber;
+        IntType: number;
+    }
+}
+declare module 'ethers/lib/utils' {
+    function getAddress(address: string): Address;
+    function isAddress(address: string): address is Address;
+    function verifyTypedData<TTypedData extends TypedData, TSchema extends TypedDataToPrimitiveTypes<TTypedData>>(domain: TypedDataDomain, types: TTypedData, value: TSchema[keyof TSchema] extends infer TValue ? {
+        [x: string]: any;
+    } extends TValue ? Record<string, any> : TValue : never, signature: {
+        r: string;
+        s?: string;
+        _vs?: string;
+        recoveryParam?: number;
+        v?: number;
+    } | ResolvedConfig['BytesType'] | string): string;
+}
 export declare type Hash = `0x${string}`;
 export declare type Chain = {
     /** ID in number form */
@@ -27,11 +46,13 @@ export declare type Chain = {
     };
     /** ENS registry */
     ens?: {
-        address: string;
+        address: Address;
     };
-    /** Chain multicall contract */
+    /**
+     * Chain [multicall3 contract](https://github.com/mds1/multicall)
+     */
     multicall?: {
-        address: string;
+        address: Address;
         blockCreated: number;
     };
     /** Flag for test networks */
@@ -83,9 +104,9 @@ declare type WatchAssetParams = {
     type: 'ERC20';
     options: {
         /** Address of token contract */
-        address: string;
+        address: Address;
         /** Number of token decimals */
-        decimals: number;
+        decimals: ResolvedConfig['IntType'];
         /** String url of token logo */
         image?: string;
         /** A ticker symbol or shorthand, up to 5 characters */
@@ -107,6 +128,7 @@ declare type InjectedProviderFlags = {
     isTokenPocket?: true;
     isTokenary?: true;
     isTrust?: true;
+    isAvalanche?: true;
 };
 declare type InjectedProviders = InjectedProviderFlags & {
     isMetaMask: true;
@@ -141,13 +163,13 @@ export interface Ethereum extends InjectedProviders {
      */
     request(args: {
         method: 'eth_accounts';
-    }): Promise<string[]>;
+    }): Promise<Address[]>;
     request(args: {
         method: 'eth_chainId';
     }): Promise<string>;
     request(args: {
         method: 'eth_requestAccounts';
-    }): Promise<string[]>;
+    }): Promise<Address[]>;
     /**
      * EIP-1474: Remote procedure call specification
      * https://eips.ethereum.org/EIPS/eip-1474

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

@@ -0,0 +1,103 @@
+/**
+ * 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'>
+ */
+export declare 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]>
+ */
+export declare 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'>
+ */
+export declare 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>
+ */
+export declare 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'], '-'>
+ */
+export declare 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'>
+ */
+export declare 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'>
+ */
+export declare 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>
+ */
+export declare 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'>
+ */
+export declare type UnionToIntersection<Union> = (Union extends unknown ? (arg: Union) => unknown : never) extends (arg: infer R) => unknown ? R : never;

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

@@ -0,0 +1,3 @@
+export declare function assertActiveChain({ chainId }: {
+    chainId: number;
+}): void;

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

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

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

@@ -1,7 +1,9 @@
 export { configureChains } from './configureChains';
 export type { ConfigureChainsConfig } from './configureChains';
+export { assertActiveChain } from './assertActiveChain';
 export { debounce } from './debounce';
 export { deepEqual } from './deepEqual';
+export { normalizeFunctionName } from './normalizeFunctionName';
 export { getInjectedName } from './getInjectedName';
 export { logWarn } from './logger';
 export { minimizeContractInterface } from './minimizeContractInterface';

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

@@ -1,5 +1,5 @@
-import { ContractInterface } from 'ethers/lib/ethers';
-export declare function minimizeContractInterface({ contractInterface, functionName, }: {
-    contractInterface: ContractInterface;
-    functionName: string;
-}): string[];
+import { Abi, ExtractAbiFunctionNames } from 'abitype';
+export declare function minimizeContractInterface<TAbi extends Abi | readonly unknown[]>(config: {
+    abi: TAbi;
+    functionName: TAbi extends Abi ? ExtractAbiFunctionNames<TAbi> : string;
+}): string[] | (import("abitype").AbiFunction | import("abitype").AbiEvent | import("abitype").AbiError)[];

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

@@ -0,0 +1,17 @@
+import { AbiParameter } from 'abitype';
+import { Contract } from 'ethers';
+/**
+ * Get normalized function name from contract
+ *
+ * @param contract — Contract
+ * @param functionName — Function name
+ * @param args — Function arguments (used to disambiguate overloaded functions)
+ *
+ * @returns Normalized function name
+ */
+export declare function normalizeFunctionName({ contract, functionName, args, }: {
+    contract: Contract;
+    functionName: string;
+    args?: readonly unknown[];
+}): string;
+export declare function isArgOfType(arg: unknown, abiParameter: AbiParameter): boolean;

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

@@ -1,7 +1,7 @@
+import { Abi } from 'abitype';
 import { ContractInterface } from 'ethers/lib/ethers';
-import { Result } from 'ethers/lib/utils';
-export declare function parseContractResult({ contractInterface, data, functionName, }: {
-    contractInterface: ContractInterface;
-    data: Result;
+export declare function parseContractResult({ abi, data, functionName, }: {
+    abi: ContractInterface | Abi | readonly unknown[];
+    data: any;
     functionName: string;
 }): any;