@wagmi/core 0.6.12 → 0.7.0

package/dist/{declarations/src/types/contracts.d.ts → contracts-fb6a6ff0.d.ts}

@@ -1,10 +1,114 @@
-import { Abi, AbiEvent, AbiFunction, AbiParameter, AbiParameterToPrimitiveType, AbiParametersToPrimitiveTypes, AbiStateMutability, Address, ExtractAbiFunction, ExtractAbiFunctionNames, Narrow, ResolvedConfig } from 'abitype';
+import { Abi, AbiFunction, AbiParametersToPrimitiveTypes, ExtractAbiFunction, Narrow, AbiStateMutability, ExtractAbiFunctionNames, AbiEvent, AbiParameterToPrimitiveType, Address, ResolvedConfig } from 'abitype';
 import { ethers } from 'ethers';
-import { IsNever, Join, NotEqual, Or } from './utils';
+
+/**
+ * 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'>
+ */
+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]>
+ */
+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'>
+ */
+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>
+ */
+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'], '-'>
+ */
+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'>
+ */
+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'>
+ */
+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>
+ */
+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'>
+ */
+declare type UnionToIntersection<Union> = (Union extends unknown ? (arg: Union) => unknown : never) extends (arg: infer R) => unknown ? R : never;
+
 /**
  * Configuration options for contract types
  */
-export declare type Options = {
+declare type Options = {
     /** Flag for making `abi` optional */
     isAbiOptional?: boolean;
     /** Flag for making `address` optional */
@@ -17,7 +121,7 @@ export declare type Options = {
 /**
  * Default {@link Options}
  */
-export declare type DefaultOptions = {
+declare type DefaultOptions = {
     isAbiOptional: false;
     isAddressOptional: false;
     isArgsOptional: false;
@@ -34,7 +138,7 @@ export declare type DefaultOptions = {
  * @example
  * type Result = GetArgs<[…], 'tokenURI'>
  */
-export declare type GetArgs<TAbi extends Abi | readonly unknown[], TFunction extends AbiFunction & {
+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 ? {
     /**
@@ -55,7 +159,7 @@ export declare type GetArgs<TAbi extends Abi | readonly unknown[], TFunction ext
 /**
  * Contract configuration object for inferring function name and arguments based on {@link TAbi}.
  */
-export declare type ContractConfig<TContract = {
+declare type ContractConfig<TContract = {
     [key: string]: unknown;
 }, TAbi extends Abi | readonly unknown[] = Abi, TFunctionName extends string = string, TFunction extends AbiFunction & {
     type: 'function';
@@ -90,7 +194,7 @@ declare type OmitConfigProperties = 'abi' | 'args' | 'functionName';
  * @example
  * type Result = GetConfig<{ abi: […], functionName: 'tokenURI' }, 'view'>
  */
-export declare type GetConfig<TContract = unknown, TAbiStateMutibility extends AbiStateMutability = AbiStateMutability, TOptions extends Options = DefaultOptions> = TContract extends {
+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 {
@@ -128,7 +232,7 @@ declare type GetResult<TAbi extends Abi | readonly unknown[] = Abi, TFunctionNam
  * @example
  * type Result = GetReturnType<{ abi: […], functionName: 'tokenURI' }>
  */
-export declare type GetReturnType<TContract = unknown> = TContract extends {
+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 {
@@ -142,7 +246,7 @@ declare type MAXIMUM_DEPTH = 20;
  * @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 {
+declare type ContractsConfig<TContracts extends unknown[], TContractProperties extends {
     [key: string]: unknown;
 } = {
     [key: string]: unknown;
@@ -164,7 +268,7 @@ export declare type ContractsConfig<TContracts extends unknown[], TContractPrope
  * @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<{
+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[];
@@ -178,7 +282,7 @@ export declare type ContractsResult<TContracts extends unknown[], Result extends
  * @example
  * type Result = AbiItemName<{ type: 'function'; name: 'Foo'; … }>
  */
-export declare type AbiItemName<TAbiItem extends (AbiFunction & {
+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<[
     ...{
@@ -194,7 +298,7 @@ export declare type AbiItemName<TAbiItem extends (AbiFunction & {
  * @example
  * type Result = GetOverridesForAbiStateMutability<'pure'>
  */
-export declare type GetOverridesForAbiStateMutability<TAbiStateMutability extends AbiStateMutability> = {
+declare type GetOverridesForAbiStateMutability<TAbiStateMutability extends AbiStateMutability> = {
     nonpayable: Overrides & {
         from?: Address;
     };
@@ -204,23 +308,24 @@ export declare type GetOverridesForAbiStateMutability<TAbiStateMutability extend
     pure: CallOverrides;
     view: CallOverrides;
 }[TAbiStateMutability];
-export interface Overrides extends ethers.Overrides {
+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 {
+interface PayableOverrides extends Overrides {
     value?: ResolvedConfig['IntType'] | ResolvedConfig['BigIntType'];
 }
-export interface CallOverrides extends PayableOverrides {
+interface CallOverrides extends PayableOverrides {
     blockTag?: ethers.CallOverrides['blockTag'];
     from?: Address;
 }
-export declare type Event<TAbiEvent extends AbiEvent> = Omit<ethers.Event, 'args' | 'event' | 'eventSignature'> & {
+declare type Event<TAbiEvent extends AbiEvent> = Omit<ethers.Event, 'args' | 'event' | 'eventSignature'> & {
     args: AbiParametersToPrimitiveTypes<TAbiEvent['inputs']>;
     event: TAbiEvent['name'];
     eventSignature: AbiItemName<TAbiEvent, true>;
 };
-export {};
+
+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, ContractConfig as g, GetArgs as h, Optional as i };

package/dist/{declarations/src/types/index.d.ts → index-bacc1c49.d.ts}

@@ -1,13 +1,80 @@
-import { Address, ResolvedConfig, TypedData, TypedDataDomain, TypedDataToPrimitiveTypes } from 'abitype';
-import { Signer as BaseSigner, BigNumber, providers } from 'ethers';
-import { BlockExplorer, BlockExplorerName, RpcProviderName, units } from '../constants';
+import { Address, TypedData, TypedDataToPrimitiveTypes, TypedDataDomain, ResolvedConfig } from 'abitype';
+import { BigNumber, providers, Signer as Signer$1 } from 'ethers';
+
+declare const chainId: {
+    readonly mainnet: 1;
+    readonly goerli: 5;
+    readonly sepolia: 11155111;
+    readonly optimism: 10;
+    readonly optimismGoerli: 420;
+    readonly polygon: 137;
+    readonly polygonMumbai: 80001;
+    readonly arbitrum: 42161;
+    readonly arbitrumGoerli: 421613;
+    readonly localhost: 1337;
+    readonly hardhat: 31337;
+    readonly foundry: 31337;
+};
+declare type ChainName = keyof typeof chainId;
+declare const mainnet: Chain;
+declare const goerli: Chain;
+declare const sepolia: Chain;
+declare const optimism: Chain;
+declare const optimismGoerli: Chain;
+declare const polygon: Chain;
+declare const polygonMumbai: Chain;
+declare const arbitrum: Chain;
+declare const arbitrumGoerli: Chain;
+declare const localhost: Chain;
+declare const hardhat: Chain;
+declare const foundry: Chain;
+/**
+ * Common chains for convenience
+ * Should not contain all possible chains
+ */
+declare const chain: {
+    readonly mainnet: Chain;
+    readonly goerli: Chain;
+    readonly sepolia: Chain;
+    readonly optimism: Chain;
+    readonly optimismGoerli: Chain;
+    readonly polygon: Chain;
+    readonly polygonMumbai: Chain;
+    readonly arbitrum: Chain;
+    readonly arbitrumGoerli: Chain;
+    readonly localhost: Chain;
+    readonly hardhat: Chain;
+    readonly foundry: Chain;
+};
+declare const allChains: Chain[];
+declare const defaultChains: Chain[];
+declare const defaultL2Chains: Chain[];
+
+declare type BlockExplorerName = 'etherscan';
+declare type BlockExplorer = {
+    name: string;
+    url: string;
+};
+declare type EtherscanChains = Extract<ChainName, 'mainnet' | 'goerli' | 'sepolia' | 'optimism' | 'optimismGoerli' | 'polygon' | 'polygonMumbai' | 'arbitrum' | 'arbitrumGoerli'>;
+declare const etherscanBlockExplorers: Record<EtherscanChains, BlockExplorer>;
+
+declare type RpcProviderName = 'alchemy' | 'infura' | 'public';
+declare type AlchemyChains = Extract<ChainName, 'mainnet' | 'goerli' | 'optimism' | 'optimismGoerli' | 'polygon' | 'polygonMumbai' | 'arbitrum' | 'arbitrumGoerli'>;
+declare const alchemyRpcUrls: Record<AlchemyChains, string>;
+declare type InfuraChains = Extract<ChainName, 'mainnet' | 'goerli' | 'sepolia' | 'optimism' | 'optimismGoerli' | 'polygon' | 'polygonMumbai' | 'arbitrum' | 'arbitrumGoerli'>;
+declare const infuraRpcUrls: Record<InfuraChains, string>;
+declare type PublicChains = Extract<ChainName, 'mainnet' | 'goerli' | 'sepolia' | 'optimism' | 'optimismGoerli' | 'polygon' | 'polygonMumbai' | 'arbitrum' | 'arbitrumGoerli'>;
+declare const publicRpcUrls: Record<PublicChains, string>;
+
+declare const units: readonly ["wei", "kwei", "mwei", "gwei", "szabo", "finney", "ether"];
+
 declare module 'abitype' {
     interface Config {
         BigIntType: BigNumber;
         IntType: number;
     }
 }
-declare module 'ethers/lib/utils' {
+declare module 'ethers/lib/utils.js' {
     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 ? {
@@ -20,8 +87,8 @@ declare module 'ethers/lib/utils' {
         v?: number;
     } | ResolvedConfig['BytesType'] | string): string;
 }
-export declare type Hash = `0x${string}`;
-export declare type Chain = {
+declare type Hash = `0x${string}`;
+declare type Chain = {
     /** ID in number form */
     id: number;
     /** Human-readable name */
@@ -58,21 +125,21 @@ export declare type Chain = {
     /** Flag for test networks */
     testnet?: boolean;
 };
-export declare type ChainProviderFn<TProvider extends Provider = providers.BaseProvider, TWebSocketProvider extends WebSocketProvider = providers.WebSocketProvider, TChain extends Chain = Chain> = (chain: TChain) => {
+declare type ChainProviderFn<TProvider extends Provider = providers.BaseProvider, TWebSocketProvider extends WebSocketProvider = providers.WebSocketProvider, TChain extends Chain = Chain> = (chain: TChain) => {
     chain: TChain;
     provider: () => ProviderWithFallbackConfig<TProvider>;
     webSocketProvider?: () => TWebSocketProvider;
 } | null;
-export declare type FallbackProviderConfig = Omit<providers.FallbackProviderConfig, 'provider'>;
-export declare type ProviderWithFallbackConfig<TProvider extends Provider = Provider> = TProvider & FallbackProviderConfig;
-export declare type Provider = providers.BaseProvider & {
+declare type FallbackProviderConfig = Omit<providers.FallbackProviderConfig, 'provider'>;
+declare type ProviderWithFallbackConfig<TProvider extends Provider = Provider> = TProvider & FallbackProviderConfig;
+declare type Provider = providers.BaseProvider & {
     chains?: Chain[];
 };
-export declare type WebSocketProvider = providers.WebSocketProvider & {
+declare type WebSocketProvider = providers.WebSocketProvider & {
     chains?: Chain[];
 };
-export declare type Signer = BaseSigner;
-export declare type Unit = typeof units[number];
+declare type Signer = Signer$1;
+declare type Unit = typeof units[number];
 declare type AddEthereumChainParameter = {
     /** A 0x-prefixed hexadecimal string */
     chainId: string;
@@ -148,7 +215,7 @@ declare type InjectedProviders = InjectedProviderFlags & {
         isUnlocked?: boolean;
     };
 };
-export interface Ethereum extends InjectedProviders {
+interface Ethereum extends InjectedProviders {
     on?: (...args: any[]) => void;
     removeListener?: (...args: any[]) => void;
     providers?: Ethereum[];
@@ -217,4 +284,5 @@ declare global {
         ethereum?: Ethereum;
     }
 }
-export {};
+
+export { Chain as C, Ethereum as E, FallbackProviderConfig as F, Hash as H, Provider as P, Signer as S, Unit as U, WebSocketProvider as W, ChainProviderFn as a, ProviderWithFallbackConfig as b, alchemyRpcUrls as c, allChains as d, chain as e, chainId as f, defaultChains as g, defaultL2Chains as h, etherscanBlockExplorers as i, infuraRpcUrls as j, arbitrum as k, arbitrumGoerli as l, foundry as m, goerli as n, hardhat as o, publicRpcUrls as p, localhost as q, mainnet as r, sepolia as s, optimism as t, units as u, optimismGoerli as v, polygon as w, polygonMumbai as x };