@wagmi/core 1.4.1 → 2.0.0

package/src/query/simulateContract.ts

@@ -0,0 +1,128 @@
+import { type QueryOptions } from '@tanstack/query-core'
+import type { Abi, ContractFunctionArgs, ContractFunctionName } from 'viem'
+
+import {
+  type SimulateContractError,
+  type SimulateContractParameters,
+  type SimulateContractReturnType,
+  simulateContract,
+} from '../actions/simulateContract.js'
+import type { Config } from '../createConfig.js'
+import type { UnionPartial } from '../types/utils.js'
+import type { ScopeKeyParameter } from './types.js'
+import { filterQueryOptions } from './utils.js'
+
+export type SimulateContractOptions<
+  abi extends Abi | readonly unknown[],
+  functionName extends ContractFunctionName<abi, 'nonpayable' | 'payable'>,
+  args extends ContractFunctionArgs<
+    abi,
+    'nonpayable' | 'payable',
+    functionName
+  >,
+  config extends Config,
+  chainId extends config['chains'][number]['id'] | undefined,
+> = UnionPartial<
+  SimulateContractParameters<abi, functionName, args, config, chainId>
+> &
+  ScopeKeyParameter
+
+export function simulateContractQueryOptions<
+  const abi extends Abi | readonly unknown[],
+  functionName extends ContractFunctionName<abi, 'nonpayable' | 'payable'>,
+  args extends ContractFunctionArgs<
+    abi,
+    'nonpayable' | 'payable',
+    functionName
+  >,
+  config extends Config,
+  chainId extends config['chains'][number]['id'] | undefined,
+>(
+  config: config,
+  options: SimulateContractOptions<
+    abi,
+    functionName,
+    args,
+    config,
+    chainId
+  > = {} as any,
+) {
+  return {
+    async queryFn({ queryKey }) {
+      const { abi, connector } = options
+      if (!abi) throw new Error('abi is required')
+      const { scopeKey: _, ...parameters } = queryKey[1]
+      const { address, functionName } = parameters
+      if (!address) throw new Error('address is required')
+      if (!functionName) throw new Error('functionName is required')
+      return simulateContract(config, { abi, connector, ...parameters } as any)
+    },
+    queryKey: simulateContractQueryKey(options),
+  } as const satisfies QueryOptions<
+    SimulateContractQueryFnData<abi, functionName, args, config, chainId>,
+    SimulateContractError,
+    SimulateContractData<abi, functionName, args, config, chainId>,
+    SimulateContractQueryKey<abi, functionName, args, config, chainId>
+  >
+}
+
+export type SimulateContractQueryFnData<
+  abi extends Abi | readonly unknown[],
+  functionName extends ContractFunctionName<abi, 'nonpayable' | 'payable'>,
+  args extends ContractFunctionArgs<
+    abi,
+    'nonpayable' | 'payable',
+    functionName
+  >,
+  config extends Config,
+  chainId extends config['chains'][number]['id'] | undefined,
+> = SimulateContractReturnType<abi, functionName, args, config, chainId>
+
+export type SimulateContractData<
+  abi extends Abi | readonly unknown[],
+  functionName extends ContractFunctionName<abi, 'nonpayable' | 'payable'>,
+  args extends ContractFunctionArgs<
+    abi,
+    'nonpayable' | 'payable',
+    functionName
+  >,
+  config extends Config,
+  chainId extends config['chains'][number]['id'] | undefined,
+> = SimulateContractQueryFnData<abi, functionName, args, config, chainId>
+
+export function simulateContractQueryKey<
+  abi extends Abi | readonly unknown[],
+  functionName extends ContractFunctionName<abi, 'nonpayable' | 'payable'>,
+  args extends ContractFunctionArgs<
+    abi,
+    'nonpayable' | 'payable',
+    functionName
+  >,
+  config extends Config,
+  chainId extends config['chains'][number]['id'] | undefined,
+>(
+  options: SimulateContractOptions<
+    abi,
+    functionName,
+    args,
+    config,
+    chainId
+  > = {} as any,
+) {
+  const { abi: _, connector: _c, ...rest } = options
+  return ['simulateContract', filterQueryOptions(rest)] as const
+}
+
+export type SimulateContractQueryKey<
+  abi extends Abi | readonly unknown[],
+  functionName extends ContractFunctionName<abi, 'nonpayable' | 'payable'>,
+  args extends ContractFunctionArgs<
+    abi,
+    'nonpayable' | 'payable',
+    functionName
+  >,
+  config extends Config,
+  chainId extends config['chains'][number]['id'] | undefined,
+> = ReturnType<
+  typeof simulateContractQueryKey<abi, functionName, args, config, chainId>
+>

package/src/query/switchAccount.ts

@@ -0,0 +1,52 @@
+import type { MutationOptions } from '@tanstack/query-core'
+
+import {
+  type SwitchAccountError,
+  type SwitchAccountParameters,
+  type SwitchAccountReturnType,
+  switchAccount,
+} from '../actions/switchAccount.js'
+import { type Config } from '../createConfig.js'
+import type { Evaluate } from '../types/utils.js'
+import type { Mutate, MutateAsync } from './types.js'
+
+export function switchAccountMutationOptions<config extends Config>(
+  config: config,
+) {
+  return {
+    mutationFn(variables) {
+      return switchAccount(config, variables)
+    },
+    mutationKey: ['switchAccount'],
+  } as const satisfies MutationOptions<
+    SwitchAccountData<config>,
+    SwitchAccountError,
+    SwitchAccountVariables
+  >
+}
+
+export type SwitchAccountData<config extends Config> = Evaluate<
+  SwitchAccountReturnType<config>
+>
+
+export type SwitchAccountVariables = Evaluate<SwitchAccountParameters>
+
+export type SwitchAccountMutate<
+  config extends Config,
+  context = unknown,
+> = Mutate<
+  SwitchAccountData<config>,
+  SwitchAccountError,
+  SwitchAccountVariables,
+  context
+>
+
+export type SwitchAccountMutateAsync<
+  config extends Config,
+  context = unknown,
+> = MutateAsync<
+  SwitchAccountData<config>,
+  SwitchAccountError,
+  SwitchAccountVariables,
+  context
+>

package/src/query/switchChain.ts

@@ -0,0 +1,67 @@
+import type { MutateOptions, MutationOptions } from '@tanstack/query-core'
+
+import {
+  type SwitchChainError,
+  type SwitchChainParameters,
+  type SwitchChainReturnType,
+  switchChain,
+} from '../actions/switchChain.js'
+import { type Config } from '../createConfig.js'
+import type { Evaluate } from '../types/utils.js'
+
+export function switchChainMutationOptions<config extends Config>(
+  config: config,
+) {
+  return {
+    mutationFn(variables) {
+      return switchChain(config, variables)
+    },
+    mutationKey: ['switchChain'],
+  } as const satisfies MutationOptions<
+    SwitchChainData<config, config['chains'][number]['id']>,
+    SwitchChainError,
+    SwitchChainVariables<config, config['chains'][number]['id']>
+  >
+}
+
+export type SwitchChainData<
+  config extends Config,
+  chainId extends config['chains'][number]['id'],
+> = Evaluate<SwitchChainReturnType<config, chainId>>
+
+export type SwitchChainVariables<
+  config extends Config,
+  chainId extends config['chains'][number]['id'],
+> = Evaluate<SwitchChainParameters<config, chainId>>
+
+export type SwitchChainMutate<config extends Config, context = unknown> = <
+  chainId extends config['chains'][number]['id'],
+>(
+  variables: SwitchChainVariables<config, chainId>,
+  options?:
+    | Evaluate<
+        MutateOptions<
+          SwitchChainData<config, chainId>,
+          SwitchChainError,
+          Evaluate<SwitchChainVariables<config, chainId>>,
+          context
+        >
+      >
+    | undefined,
+) => void
+
+export type SwitchChainMutateAsync<config extends Config, context = unknown> = <
+  chainId extends config['chains'][number]['id'],
+>(
+  variables: SwitchChainVariables<config, chainId>,
+  options?:
+    | Evaluate<
+        MutateOptions<
+          SwitchChainData<config, chainId>,
+          SwitchChainError,
+          Evaluate<SwitchChainVariables<config, chainId>>,
+          context
+        >
+      >
+    | undefined,
+) => Promise<SwitchChainData<config, chainId>>

package/src/query/types.ts

@@ -0,0 +1,52 @@
+import type { Evaluate } from '../types/utils.js'
+
+export type ScopeKeyParameter = { scopeKey?: string | undefined }
+
+type MutateFn<
+  data = unknown,
+  error = unknown,
+  variables = void,
+  context = unknown,
+> = undefined extends variables
+  ? (
+      variables?: variables,
+      options?:
+        | Evaluate<
+            import('@tanstack/query-core').MutateOptions<
+              data,
+              error,
+              variables,
+              context
+            >
+          >
+        | undefined,
+    ) => Promise<data>
+  : (
+      variables: variables,
+      options?:
+        | Evaluate<
+            import('@tanstack/query-core').MutateOptions<
+              data,
+              error,
+              variables,
+              context
+            >
+          >
+        | undefined,
+    ) => Promise<data>
+
+export type Mutate<
+  data = unknown,
+  error = unknown,
+  variables = void,
+  context = unknown,
+> = (
+  ...args: Parameters<MutateFn<data, error, Evaluate<variables>, context>>
+) => void
+
+export type MutateAsync<
+  data = unknown,
+  error = unknown,
+  variables = void,
+  context = unknown,
+> = MutateFn<data, error, Evaluate<variables>, context>

package/src/query/utils.ts

@@ -0,0 +1,54 @@
+import type { QueryKey } from '@tanstack/query-core'
+
+export function hashFn(queryKey: QueryKey): string {
+  return JSON.stringify(queryKey, (_, value) => {
+    if (isPlainObject(value))
+      return Object.keys(value)
+        .sort()
+        .reduce((result, key) => {
+          result[key] = value[key]
+          return result
+        }, {} as any)
+    if (typeof value === 'bigint') return value.toString()
+    return value
+  })
+}
+
+function isPlainObject(o: any): o is Object {
+  if (!hasObjectPrototype(o)) {
+    return false
+  }
+
+  // If has modified constructor
+  const ctor = o.constructor
+  if (typeof ctor === 'undefined') return true
+
+  // If has modified prototype
+  const prot = ctor.prototype
+  if (!hasObjectPrototype(prot)) return false
+
+  // If constructor does not have an Object-specific method
+  // biome-ignore lint/suspicious/noPrototypeBuiltins: <explanation>
+  if (!prot.hasOwnProperty('isPrototypeOf')) return false
+
+  // Most likely a plain Object
+  return true
+}
+
+function hasObjectPrototype(o: any): boolean {
+  return Object.prototype.toString.call(o) === '[object Object]'
+}
+
+export function filterQueryOptions<type extends Record<string, unknown>>(
+  options: type,
+): type {
+  // destructuring is super fast
+  // biome-ignore format: no formatting
+  const {
+    // biome-ignore lint/correctness/noUnusedVariables: remove properties
+    config, connector, query,
+    ...rest
+  } = options
+
+  return rest as type
+}

package/src/query/waitForTransactionReceipt.ts

@@ -0,0 +1,71 @@
+import { type QueryOptions } from '@tanstack/query-core'
+
+import {
+  type WaitForTransactionReceiptError,
+  type WaitForTransactionReceiptParameters,
+  type WaitForTransactionReceiptReturnType,
+  waitForTransactionReceipt,
+} from '../actions/waitForTransactionReceipt.js'
+import type { Config } from '../createConfig.js'
+import type { Evaluate, ExactPartial } from '../types/utils.js'
+import type { ScopeKeyParameter } from './types.js'
+import { filterQueryOptions } from './utils.js'
+
+export type WaitForTransactionReceiptOptions<
+  config extends Config,
+  chainId extends config['chains'][number]['id'],
+> = Evaluate<
+  ExactPartial<WaitForTransactionReceiptParameters<config, chainId>> &
+    ScopeKeyParameter
+>
+
+export function waitForTransactionReceiptQueryOptions<
+  config extends Config,
+  chainId extends config['chains'][number]['id'],
+>(
+  config: Config,
+  options: WaitForTransactionReceiptOptions<config, chainId> = {},
+) {
+  return {
+    async queryFn({ queryKey }) {
+      const { hash, ...parameters } = queryKey[1]
+      if (!hash) throw new Error('hash is required')
+      return waitForTransactionReceipt(config, {
+        ...parameters,
+        onReplaced: options.onReplaced,
+        hash,
+      }) as unknown as Promise<
+        WaitForTransactionReceiptReturnType<config, chainId>
+      >
+    },
+    queryKey: waitForTransactionReceiptQueryKey(options),
+  } as const satisfies QueryOptions<
+    WaitForTransactionReceiptQueryFnData<config, chainId>,
+    WaitForTransactionReceiptError,
+    WaitForTransactionReceiptData<config, chainId>,
+    WaitForTransactionReceiptQueryKey<config, chainId>
+  >
+}
+
+export type WaitForTransactionReceiptQueryFnData<
+  config extends Config,
+  chainId extends config['chains'][number]['id'],
+> = WaitForTransactionReceiptReturnType<config, chainId>
+
+export type WaitForTransactionReceiptData<
+  config extends Config,
+  chainId extends config['chains'][number]['id'],
+> = WaitForTransactionReceiptQueryFnData<config, chainId>
+
+export function waitForTransactionReceiptQueryKey<
+  config extends Config,
+  chainId extends config['chains'][number]['id'],
+>(options: WaitForTransactionReceiptOptions<config, chainId> = {}) {
+  const { onReplaced: _, ...rest } = options
+  return ['waitForTransactionReceipt', filterQueryOptions(rest)] as const
+}
+
+export type WaitForTransactionReceiptQueryKey<
+  config extends Config,
+  chainId extends config['chains'][number]['id'],
+> = ReturnType<typeof waitForTransactionReceiptQueryKey<config, chainId>>

package/src/query/writeContract.ts

@@ -0,0 +1,91 @@
+import type { MutateOptions, MutationOptions } from '@tanstack/query-core'
+import type { Abi, ContractFunctionArgs, ContractFunctionName } from 'viem'
+
+import {
+  type WriteContractError,
+  type WriteContractParameters,
+  type WriteContractReturnType,
+  writeContract,
+} from '../actions/writeContract.js'
+import { type Config } from '../createConfig.js'
+import type { Evaluate } from '../types/utils.js'
+
+export function writeContractMutationOptions<config extends Config>(
+  config: config,
+) {
+  return {
+    mutationFn(variables) {
+      return writeContract(config, variables)
+    },
+    mutationKey: ['writeContract'],
+  } as const satisfies MutationOptions<
+    WriteContractData,
+    WriteContractError,
+    WriteContractVariables<
+      Abi,
+      string,
+      readonly unknown[],
+      config,
+      config['chains'][number]['id']
+    >
+  >
+}
+
+export type WriteContractData = Evaluate<WriteContractReturnType>
+
+export type WriteContractVariables<
+  abi extends Abi | readonly unknown[],
+  functionName extends ContractFunctionName<abi, 'nonpayable' | 'payable'>,
+  args extends ContractFunctionArgs<
+    abi,
+    'nonpayable' | 'payable',
+    functionName
+  >,
+  config extends Config,
+  chainId extends config['chains'][number]['id'],
+> = WriteContractParameters<abi, functionName, args, config, chainId>
+
+export type WriteContractMutate<config extends Config, context = unknown> = <
+  const abi extends Abi | readonly unknown[],
+  functionName extends ContractFunctionName<abi, 'nonpayable' | 'payable'>,
+  args extends ContractFunctionArgs<
+    abi,
+    'nonpayable' | 'payable',
+    functionName
+  >,
+  chainId extends config['chains'][number]['id'],
+>(
+  variables: WriteContractVariables<abi, functionName, args, config, chainId>,
+  options?:
+    | MutateOptions<
+        WriteContractData,
+        WriteContractError,
+        WriteContractVariables<abi, functionName, args, config, chainId>,
+        context
+      >
+    | undefined,
+) => void
+
+export type WriteContractMutateAsync<
+  config extends Config,
+  context = unknown,
+> = <
+  const abi extends Abi | readonly unknown[],
+  functionName extends ContractFunctionName<abi, 'nonpayable' | 'payable'>,
+  args extends ContractFunctionArgs<
+    abi,
+    'nonpayable' | 'payable',
+    functionName
+  >,
+  chainId extends config['chains'][number]['id'],
+>(
+  variables: WriteContractVariables<abi, functionName, args, config, chainId>,
+  options?:
+    | MutateOptions<
+        WriteContractData,
+        WriteContractError,
+        WriteContractVariables<abi, functionName, args, config, chainId>,
+        context
+      >
+    | undefined,
+) => Promise<WriteContractData>

package/src/types/chain.ts

@@ -0,0 +1,25 @@
+import type { Chain, ChainFormatters } from 'viem'
+
+import type { Config } from '../createConfig.js'
+import type { IsNarrowable, Merge } from './utils.js'
+
+/** Filters {@link Config} chains by {@link chainId} or simplifies if no `ChainFormatters` are present. */
+export type SelectChains<
+  config extends Config,
+  chainId extends config['chains'][number]['id'] | undefined = undefined,
+> = Config extends config
+  ? readonly [Chain] // chains not inferrable, return default
+  : IsNarrowable<chainId, config['chains'][number]['id']> extends true
+  ? readonly [Extract<config['chains'][number], { id: chainId }>] // select specific chain
+  : HasFormatter<config['chains']> extends true
+  ? config['chains'] // return all chains since one has formatter
+  : readonly [Merge<Chain, { id: config['chains'][number]['id'] }>] // return default chain with ID set to union (allows for more simple type since the only thing that is different is the chain ID for each chain)
+
+type HasFormatter<chains extends readonly Chain[]> = chains extends readonly [
+  infer head extends Chain,
+  ...infer tail extends readonly Chain[],
+]
+  ? IsNarrowable<head['formatters'], ChainFormatters | undefined> extends true
+    ? true
+    : HasFormatter<tail>
+  : false

package/src/types/properties.ts

@@ -0,0 +1,21 @@
+import type { Config, Connector } from '../createConfig.js'
+
+export type ChainIdParameter<
+  config extends Config,
+  chainId extends
+    | config['chains'][number]['id']
+    | undefined = config['chains'][number]['id'],
+> = {
+  chainId?:
+    | (chainId extends config['chains'][number]['id'] ? chainId : undefined)
+    | config['chains'][number]['id']
+    | undefined
+}
+
+export type ConnectorParameter = {
+  connector?: Connector | undefined
+}
+
+export type SyncConnectedChainParameter = {
+  syncConnectedChain?: boolean | undefined
+}

package/src/types/register.ts

@@ -0,0 +1,8 @@
+import type { Config } from '../createConfig.js'
+
+export type Register = {}
+export type ResolvedRegister = {
+  config: Register extends { config: infer config extends Config }
+    ? config
+    : Config
+}

package/src/types/unit.ts

@@ -0,0 +1 @@
+export type Unit = 'ether' | 'gwei' | 'wei' | number

package/src/types/utils.ts

@@ -0,0 +1,85 @@
+/** Combines members of an intersection into a readable type. */
+// https://twitter.com/mattpocockuk/status/1622730173446557697?s=20&t=NdpAcmEFXY01xkqU3KO0Mg
+export type Evaluate<type> = { [key in keyof type]: type[key] } & unknown
+
+/**
+ * Makes all properties of an object optional.
+ *
+ * Compatible with [`exactOptionalPropertyTypes`](https://www.typescriptlang.org/tsconfig#exactOptionalPropertyTypes).
+ */
+export type ExactPartial<type> = {
+  [key in keyof type]?: type[key] | undefined
+}
+
+/** Checks if {@link type} can be narrowed further than {@link type2} */
+export type IsNarrowable<type, type2> = IsUnknown<type> extends true
+  ? false
+  : IsNever<
+      (type extends type2 ? true : false) & (type2 extends type ? false : true)
+    > extends true
+  ? false
+  : true
+
+/** Checks if {@link type} is `never` */
+export type IsNever<type> = [type] extends [never] ? true : false
+
+/** Checks if {@link type} is `unknown` */
+export type IsUnknown<type> = unknown extends type ? true : false
+
+/** Merges two object types into new type  */
+export type Merge<obj1, obj2> = Evaluate<
+  LooseOmit<obj1, keyof obj2 extends infer key extends string ? key : never> &
+    obj2
+>
+
+/** Removes `readonly` from all properties of an object. */
+export type Mutable<type extends object> = {
+  -readonly [key in keyof type]: type[key]
+}
+
+/** Strict version of built-in Omit type */
+export type Omit<type, keys extends keyof type> = Pick<
+  type,
+  Exclude<keyof type, keys>
+>
+
+/** Makes objects destructurable. */
+export type OneOf<
+  union extends object,
+  ///
+  keys extends KeyofUnion<union> = KeyofUnion<union>,
+> = union extends infer Item
+  ? Evaluate<Item & { [K in Exclude<keys, keyof Item>]?: undefined }>
+  : never
+type KeyofUnion<type> = type extends type ? keyof type : never
+
+/** Makes {@link key} optional in {@link type} while preserving type inference. */
+// s/o trpc (https://github.com/trpc/trpc/blob/main/packages/server/src/types.ts#L6)
+export type PartialBy<type, key extends keyof type> = ExactPartial<
+  Pick<type, key>
+> &
+  Omit<type, key>
+
+///////////////////////////////////////////////////////////////////////////
+// Loose types
+
+/** Loose version of {@link Omit} */
+export type LooseOmit<type, keys extends string> = Pick<
+  type,
+  Exclude<keyof type, keys>
+>
+
+///////////////////////////////////////////////////////////////////////////
+// Union types
+
+export type UnionEvaluate<type> = type extends object ? Evaluate<type> : type
+
+export type UnionLooseOmit<type, keys extends string> = type extends any
+  ? LooseOmit<type, keys>
+  : never
+
+export type UnionOmit<type, keys extends keyof type> = type extends any
+  ? Omit<type, keys>
+  : never
+
+export type UnionPartial<type> = type extends object ? ExactPartial<type> : type

package/src/utils/assertActiveChain.ts

@@ -0,0 +1,26 @@
+import { getChainId } from '../actions/getChainId.js'
+import type { Config } from '../createConfig.js'
+import { ChainMismatchError } from '../errors/config.js'
+
+type AssertActiveChainParamters = {
+  activeChainId?: number | undefined
+  chainId: number
+}
+
+export function assertActiveChain(
+  config: Config,
+  parameters: AssertActiveChainParamters,
+) {
+  const { chainId } = parameters
+
+  // Check that active chain and target chain match
+  const activeChainId = parameters.activeChainId ?? getChainId(config)
+  if (activeChainId && chainId !== activeChainId) {
+    const activeChain =
+      config.chains.find((x) => x.id === activeChainId)?.name ??
+      `Chain ${activeChainId}`
+    const targetChain =
+      config.chains.find((x) => x.id === chainId)?.name ?? `Chain ${chainId}`
+    throw new ChainMismatchError({ activeChain, targetChain })
+  }
+}