@ensdomains/ensjs-query-core 0.0.1

package/src/query/public/getAvailable.ts

@@ -0,0 +1,61 @@
+import {
+  ASSERT_NO_TYPE_ERROR,
+  type ExcludeTE,
+} from '@ensdomains/ensjs/internal'
+import type { QueryOptions } from '@tanstack/query-core'
+import type { Config } from '@wagmi/core'
+import type {
+  Compute,
+  ExactPartial,
+  ScopeKeyParameter,
+} from '@wagmi/core/internal'
+import type { Chain } from 'viem'
+import {
+  type GetAvailableErrorType,
+  type GetAvailableParameters,
+  type GetAvailableReturnType,
+  getAvailable,
+} from '../../actions/public/getAvailable.js'
+import type { RequireConfigContracts } from '../../utils/chain.js'
+import { filterQueryOptions } from '../utils.js'
+
+export type GetAvailableOptions<config extends Config> = Compute<
+  ExactPartial<GetAvailableParameters<config>> & ScopeKeyParameter
+>
+
+export function getAvailableQueryOptions<
+  chains extends readonly [Chain, ...Chain[]],
+>(
+  config: RequireConfigContracts<chains, 'ensBaseRegistrarImplementation'>,
+  options: GetAvailableOptions<ExcludeTE<typeof config>> = {},
+) {
+  ASSERT_NO_TYPE_ERROR(config)
+
+  return {
+    async queryFn({ queryKey }) {
+      const { name, scopeKey: _, ...parameters } = queryKey[1]
+      if (!name) throw new Error('name is required')
+      return getAvailable<chains>(config, { ...parameters, name })
+    },
+    queryKey: getAvailableQueryKey(options),
+  } as const satisfies QueryOptions<
+    GetAvailableQueryFnData,
+    GetAvailableErrorType,
+    GetAvailableData,
+    GetAvailableQueryKey<typeof config>
+  >
+}
+
+export type GetAvailableQueryFnData = GetAvailableReturnType
+
+export type GetAvailableData = GetAvailableQueryFnData
+
+export function getAvailableQueryKey<config extends Config>(
+  options: GetAvailableOptions<config> = {},
+) {
+  return ['ensjs_available', filterQueryOptions(options)] as const
+}
+
+export type GetAvailableQueryKey<config extends Config> = ReturnType<
+  typeof getAvailableQueryKey<config>
+>

package/src/query/public/getContentHashRecord.ts

@@ -0,0 +1,61 @@
+import {
+  ASSERT_NO_TYPE_ERROR,
+  type ExcludeTE,
+} from '@ensdomains/ensjs/internal'
+import type { QueryOptions } from '@tanstack/query-core'
+import type { Config } from '@wagmi/core'
+import type {
+  Compute,
+  ExactPartial,
+  ScopeKeyParameter,
+} from '@wagmi/core/internal'
+import type { Chain } from 'viem'
+import {
+  type GetContentHashRecordErrorType,
+  type GetContentHashRecordParameters,
+  type GetContentHashRecordReturnType,
+  getContentHashRecord,
+} from '../../actions/public/getContentHashRecord.js'
+import type { RequireConfigContracts } from '../../utils/chain.js'
+import { filterQueryOptions } from '../utils.js'
+
+export type GetContentHashRecordOptions<config extends Config> = Compute<
+  ExactPartial<GetContentHashRecordParameters<config>> & ScopeKeyParameter
+>
+
+export function getContentHashRecordQueryOptions<
+  chains extends readonly [Chain, ...Chain[]],
+>(
+  config: RequireConfigContracts<chains, 'ensUniversalResolver'>,
+  options: GetContentHashRecordOptions<ExcludeTE<typeof config>> = {},
+) {
+  ASSERT_NO_TYPE_ERROR(config)
+
+  return {
+    async queryFn({ queryKey }) {
+      const { name, scopeKey: _, ...parameters } = queryKey[1]
+      if (!name) throw new Error('name is required')
+      return getContentHashRecord<chains>(config, { ...parameters, name })
+    },
+    queryKey: getContentHashRecordQueryKey(options),
+  } as const satisfies QueryOptions<
+    GetContentHashRecordQueryFnData,
+    GetContentHashRecordErrorType,
+    GetContentHashRecordData,
+    GetContentHashRecordQueryKey<typeof config>
+  >
+}
+
+export type GetContentHashRecordQueryFnData = GetContentHashRecordReturnType
+
+export type GetContentHashRecordData = GetContentHashRecordQueryFnData
+
+export function getContentHashRecordQueryKey<config extends Config>(
+  options: GetContentHashRecordOptions<config> = {},
+) {
+  return ['ensjs_contentHashRecord', filterQueryOptions(options)] as const
+}
+
+export type GetContentHashRecordQueryKey<config extends Config> = ReturnType<
+  typeof getContentHashRecordQueryKey<config>
+>

package/src/query/public/getCredentials.ts

@@ -0,0 +1,61 @@
+import {
+  ASSERT_NO_TYPE_ERROR,
+  type ExcludeTE,
+} from '@ensdomains/ensjs/internal'
+import type { QueryOptions } from '@tanstack/query-core'
+import type { Config } from '@wagmi/core'
+import type {
+  Compute,
+  ExactPartial,
+  ScopeKeyParameter,
+} from '@wagmi/core/internal'
+import type { Chain } from 'viem'
+import {
+  type GetCredentialsErrorType,
+  type GetCredentialsParameters,
+  type GetCredentialsReturnType,
+  getCredentials,
+} from '../../actions/public/getCredentials.js'
+import type { RequireConfigContracts } from '../../utils/chain.js'
+import { filterQueryOptions } from '../utils.js'
+
+export type GetCredentialsOptions<config extends Config> = Compute<
+  ExactPartial<GetCredentialsParameters<config>> & ScopeKeyParameter
+>
+
+export function getCredentialsQueryOptions<
+  chains extends readonly [Chain, ...Chain[]],
+>(
+  config: RequireConfigContracts<chains, 'ensUniversalResolver'>,
+  options: GetCredentialsOptions<ExcludeTE<typeof config>> = {},
+) {
+  ASSERT_NO_TYPE_ERROR(config)
+
+  return {
+    async queryFn({ queryKey }) {
+      const { name, scopeKey: _, ...parameters } = queryKey[1]
+      if (!name) throw new Error('name is required')
+      return getCredentials<chains>(config, { ...parameters, name })
+    },
+    queryKey: getCredentialsQueryKey(options),
+  } as const satisfies QueryOptions<
+    GetCredentialsQueryFnData,
+    GetCredentialsErrorType,
+    GetCredentialsData,
+    GetCredentialsQueryKey<typeof config>
+  >
+}
+
+export type GetCredentialsQueryFnData = GetCredentialsReturnType
+
+export type GetCredentialsData = GetCredentialsQueryFnData
+
+export function getCredentialsQueryKey<config extends Config>(
+  options: GetCredentialsOptions<config> = {},
+) {
+  return ['ensjs_credentials', filterQueryOptions(options)] as const
+}
+
+export type GetCredentialsQueryKey<config extends Config> = ReturnType<
+  typeof getCredentialsQueryKey<config>
+>

package/src/query/public/getExpiry.ts

@@ -0,0 +1,64 @@
+import {
+  ASSERT_NO_TYPE_ERROR,
+  type ExcludeTE,
+} from '@ensdomains/ensjs/internal'
+import type { QueryOptions } from '@tanstack/query-core'
+import type { Config } from '@wagmi/core'
+import type {
+  Compute,
+  ExactPartial,
+  ScopeKeyParameter,
+} from '@wagmi/core/internal'
+import type { Chain } from 'viem'
+import {
+  type GetExpiryErrorType,
+  type GetExpiryParameters,
+  type GetExpiryReturnType,
+  getExpiry,
+} from '../../actions/public/getExpiry.js'
+import type { RequireConfigContracts } from '../../utils/chain.js'
+import { filterQueryOptions } from '../utils.js'
+
+export type GetExpiryOptions<config extends Config> = Compute<
+  ExactPartial<GetExpiryParameters<config>> & ScopeKeyParameter
+>
+
+export function getExpiryQueryOptions<
+  chains extends readonly [Chain, ...Chain[]],
+>(
+  config: RequireConfigContracts<
+    chains,
+    'ensNameWrapper' | 'ensBaseRegistrarImplementation' | 'multicall3'
+  >,
+  options: GetExpiryOptions<ExcludeTE<typeof config>> = {},
+) {
+  ASSERT_NO_TYPE_ERROR(config)
+
+  return {
+    async queryFn({ queryKey }) {
+      const { name, scopeKey: _, ...parameters } = queryKey[1]
+      if (!name) throw new Error('name is required')
+      return getExpiry<chains>(config, { ...parameters, name })
+    },
+    queryKey: getExpiryQueryKey(options),
+  } as const satisfies QueryOptions<
+    GetExpiryQueryFnData,
+    GetExpiryErrorType,
+    GetExpiryData,
+    GetExpiryQueryKey<typeof config>
+  >
+}
+
+export type GetExpiryQueryFnData = GetExpiryReturnType
+
+export type GetExpiryData = GetExpiryQueryFnData
+
+export function getExpiryQueryKey<config extends Config>(
+  options: GetExpiryOptions<config> = {},
+) {
+  return ['ensjs_expiry', filterQueryOptions(options)] as const
+}
+
+export type GetExpiryQueryKey<config extends Config> = ReturnType<
+  typeof getExpiryQueryKey<config>
+>

package/src/query/public/getName.ts

@@ -0,0 +1,61 @@
+import {
+  ASSERT_NO_TYPE_ERROR,
+  type ExcludeTE,
+} from '@ensdomains/ensjs/internal'
+import type { QueryOptions } from '@tanstack/query-core'
+import type { Config } from '@wagmi/core'
+import type {
+  Compute,
+  ExactPartial,
+  ScopeKeyParameter,
+} from '@wagmi/core/internal'
+import type { Chain } from 'viem'
+import {
+  type GetNameErrorType,
+  type GetNameParameters,
+  type GetNameReturnType,
+  getName,
+} from '../../actions/public/getName.js'
+import type { RequireConfigContracts } from '../../utils/chain.js'
+import { filterQueryOptions } from '../utils.js'
+
+export type GetNameOptions<config extends Config> = Compute<
+  ExactPartial<GetNameParameters<config>> & ScopeKeyParameter
+>
+
+export function getNameQueryOptions<
+  chains extends readonly [Chain, ...Chain[]],
+>(
+  config: RequireConfigContracts<chains, 'ensUniversalResolver'>,
+  options: GetNameOptions<ExcludeTE<typeof config>> = {},
+) {
+  ASSERT_NO_TYPE_ERROR(config)
+
+  return {
+    async queryFn({ queryKey }) {
+      const { address, scopeKey: _, ...parameters } = queryKey[1]
+      if (!address) throw new Error('address is required')
+      return getName<chains>(config, { ...parameters, address })
+    },
+    queryKey: getNameQueryKey(options),
+  } as const satisfies QueryOptions<
+    GetNameQueryFnData,
+    GetNameErrorType,
+    GetNameData,
+    GetNameQueryKey<typeof config>
+  >
+}
+
+export type GetNameQueryFnData = GetNameReturnType
+
+export type GetNameData = GetNameQueryFnData
+
+export function getNameQueryKey<config extends Config>(
+  options: GetNameOptions<config> = {},
+) {
+  return ['ensjs_name', filterQueryOptions(options)] as const
+}
+
+export type GetNameQueryKey<config extends Config> = ReturnType<
+  typeof getNameQueryKey<config>
+>

package/src/query/public/getOwner.ts

@@ -0,0 +1,67 @@
+import {
+  ASSERT_NO_TYPE_ERROR,
+  type ExcludeTE,
+} from '@ensdomains/ensjs/internal'
+import type { QueryOptions } from '@tanstack/query-core'
+import type { Config } from '@wagmi/core'
+import type {
+  Compute,
+  ExactPartial,
+  ScopeKeyParameter,
+} from '@wagmi/core/internal'
+import type { Chain } from 'viem'
+import {
+  type GetOwnerErrorType,
+  type GetOwnerParameters,
+  type GetOwnerReturnType,
+  getOwner,
+} from '../../actions/public/getOwner.js'
+import type { RequireConfigContracts } from '../../utils/chain.js'
+import { filterQueryOptions } from '../utils.js'
+
+export type GetOwnerOptions<config extends Config> = Compute<
+  ExactPartial<GetOwnerParameters<config>> & ScopeKeyParameter
+>
+
+export function getOwnerQueryOptions<
+  chains extends readonly [Chain, ...Chain[]],
+>(
+  config: RequireConfigContracts<
+    chains,
+    | 'ensNameWrapper'
+    | 'ensRegistry'
+    | 'ensBaseRegistrarImplementation'
+    | 'multicall3'
+  >,
+  options: GetOwnerOptions<ExcludeTE<typeof config>> = {},
+) {
+  ASSERT_NO_TYPE_ERROR(config)
+
+  return {
+    async queryFn({ queryKey }) {
+      const { name, scopeKey: _, ...parameters } = queryKey[1]
+      if (!name) throw new Error('name is required')
+      return getOwner<chains>(config, { ...parameters, name })
+    },
+    queryKey: getOwnerQueryKey(options),
+  } as const satisfies QueryOptions<
+    GetOwnerQueryFnData,
+    GetOwnerErrorType,
+    GetOwnerData,
+    GetOwnerQueryKey<typeof config>
+  >
+}
+
+export type GetOwnerQueryFnData = GetOwnerReturnType
+
+export type GetOwnerData = GetOwnerQueryFnData
+
+export function getOwnerQueryKey<config extends Config>(
+  options: GetOwnerOptions<config> = {},
+) {
+  return ['ensjs_owner', filterQueryOptions(options)] as const
+}
+
+export type GetOwnerQueryKey<config extends Config> = ReturnType<
+  typeof getOwnerQueryKey<config>
+>

package/src/query/public/getPrice.ts

@@ -0,0 +1,65 @@
+import {
+  ASSERT_NO_TYPE_ERROR,
+  type ExcludeTE,
+} from '@ensdomains/ensjs/internal'
+import type { QueryOptions } from '@tanstack/query-core'
+import type { Config } from '@wagmi/core'
+import type {
+  Compute,
+  ExactPartial,
+  ScopeKeyParameter,
+} from '@wagmi/core/internal'
+import type { Chain } from 'viem'
+import {
+  type GetPriceErrorType,
+  type GetPriceParameters,
+  type GetPriceReturnType,
+  getPrice,
+} from '../../actions/public/getPrice.js'
+import type { RequireConfigContracts } from '../../utils/chain.js'
+import { filterQueryOptions } from '../utils.js'
+
+export type GetPriceOptions<config extends Config> = Compute<
+  ExactPartial<GetPriceParameters<config>> & ScopeKeyParameter
+>
+
+export function getPriceQueryOptions<
+  chains extends readonly [Chain, ...Chain[]],
+>(
+  config: RequireConfigContracts<
+    chains,
+    'ensEthRegistrarController' | 'multicall3'
+  >,
+  options: GetPriceOptions<ExcludeTE<typeof config>> = {},
+) {
+  ASSERT_NO_TYPE_ERROR(config)
+
+  return {
+    async queryFn({ queryKey }) {
+      const { nameOrNames, duration, scopeKey: _, ...parameters } = queryKey[1]
+      if (!nameOrNames) throw new Error('nameOrNames is required')
+      if (duration === undefined) throw new Error('duration is required')
+      return getPrice<chains>(config, { ...parameters, nameOrNames, duration })
+    },
+    queryKey: getPriceQueryKey(options),
+  } as const satisfies QueryOptions<
+    GetPriceQueryFnData,
+    GetPriceErrorType,
+    GetPriceData,
+    GetPriceQueryKey<typeof config>
+  >
+}
+
+export type GetPriceQueryFnData = GetPriceReturnType
+
+export type GetPriceData = GetPriceQueryFnData
+
+export function getPriceQueryKey<config extends Config>(
+  options: GetPriceOptions<config> = {},
+) {
+  return ['ensjs_price', filterQueryOptions(options)] as const
+}
+
+export type GetPriceQueryKey<config extends Config> = ReturnType<
+  typeof getPriceQueryKey<config>
+>

package/src/query/public/getRecords.ts

@@ -0,0 +1,83 @@
+import {
+  ASSERT_NO_TYPE_ERROR,
+  type ExcludeTE,
+} from '@ensdomains/ensjs/internal'
+import type { QueryOptions } from '@tanstack/query-core'
+import type { Config } from '@wagmi/core'
+import type {
+  Compute,
+  ExactPartial,
+  ScopeKeyParameter,
+} from '@wagmi/core/internal'
+import type { Chain } from 'viem'
+import {
+  type GetRecordsErrorType,
+  type GetRecordsParameters,
+  type GetRecordsReturnType,
+  getRecords,
+} from '../../actions/public/getRecords.js'
+import type { RequireConfigContracts } from '../../utils/chain.js'
+import { filterQueryOptions } from '../utils.js'
+
+export type GetRecordsOptions<
+  config extends Config,
+  texts extends readonly string[] | undefined = undefined,
+  coins extends readonly (string | number)[] | undefined = undefined,
+  contentHash extends boolean | undefined = undefined,
+  abi extends boolean | undefined = undefined,
+> = Compute<
+  ExactPartial<GetRecordsParameters<config, texts, coins, contentHash, abi>> &
+    ScopeKeyParameter
+>
+
+export function getRecordsQueryOptions<
+  chains extends readonly [Chain, ...Chain[]],
+  const texts extends readonly string[] | undefined = undefined,
+  const coins extends readonly (string | number)[] | undefined = undefined,
+  const contentHash extends boolean | undefined = undefined,
+  const abi extends boolean | undefined = undefined,
+>(
+  config: RequireConfigContracts<chains, 'ensUniversalResolver' | 'multicall3'>,
+  options: GetRecordsOptions<ExcludeTE<typeof config>> = {},
+) {
+  ASSERT_NO_TYPE_ERROR(config)
+
+  return {
+    async queryFn({ queryKey }) {
+      const { name, scopeKey: _, ...parameters } = queryKey[1]
+      if (!name) throw new Error('name is required')
+      return getRecords<chains, texts, coins, contentHash, abi>(config, {
+        ...parameters,
+        name,
+      })
+    },
+    queryKey: getRecordsQueryKey(options),
+  } as const satisfies QueryOptions<
+    GetRecordsQueryFnData<texts, coins, contentHash, abi>,
+    GetRecordsErrorType,
+    GetRecordsData,
+    GetRecordsQueryKey<typeof config>
+  >
+}
+
+export type GetRecordsQueryFnData<
+  texts extends readonly string[] | undefined = readonly string[],
+  coins extends readonly (string | number)[] | undefined = readonly (
+    | string
+    | number
+  )[],
+  contentHash extends boolean | undefined = true,
+  abi extends boolean | undefined = true,
+> = GetRecordsReturnType<texts, coins, contentHash, abi>
+
+export type GetRecordsData = GetRecordsQueryFnData
+
+export function getRecordsQueryKey<config extends Config>(
+  options: GetRecordsOptions<config> = {},
+) {
+  return ['ensjs_records', filterQueryOptions(options)] as const
+}
+
+export type GetRecordsQueryKey<config extends Config> = ReturnType<
+  typeof getRecordsQueryKey<config>
+>

package/src/query/public/getResolver.ts

@@ -0,0 +1,61 @@
+import {
+  ASSERT_NO_TYPE_ERROR,
+  type ExcludeTE,
+} from '@ensdomains/ensjs/internal'
+import type { QueryOptions } from '@tanstack/query-core'
+import type { Config } from '@wagmi/core'
+import type {
+  Compute,
+  ExactPartial,
+  ScopeKeyParameter,
+} from '@wagmi/core/internal'
+import type { Chain } from 'viem'
+import {
+  type GetResolverErrorType,
+  type GetResolverParameters,
+  type GetResolverReturnType,
+  getResolver,
+} from '../../actions/public/getResolver.js'
+import type { RequireConfigContracts } from '../../utils/chain.js'
+import { filterQueryOptions } from '../utils.js'
+
+export type GetResolverOptions<config extends Config> = Compute<
+  ExactPartial<GetResolverParameters<config>> & ScopeKeyParameter
+>
+
+export function getResolverQueryOptions<
+  chains extends readonly [Chain, ...Chain[]],
+>(
+  config: RequireConfigContracts<chains, 'ensRegistry'>,
+  options: GetResolverOptions<ExcludeTE<typeof config>> = {},
+) {
+  ASSERT_NO_TYPE_ERROR(config)
+
+  return {
+    async queryFn({ queryKey }) {
+      const { name, scopeKey: _, ...parameters } = queryKey[1]
+      if (!name) throw new Error('name is required')
+      return getResolver<chains>(config, { ...parameters, name })
+    },
+    queryKey: getResolverQueryKey(options),
+  } as const satisfies QueryOptions<
+    GetResolverQueryFnData,
+    GetResolverErrorType,
+    GetResolverData,
+    GetResolverQueryKey<typeof config>
+  >
+}
+
+export type GetResolverQueryFnData = GetResolverReturnType
+
+export type GetResolverData = GetResolverQueryFnData
+
+export function getResolverQueryKey<config extends Config>(
+  options: GetResolverOptions<config> = {},
+) {
+  return ['ensjs_resolver', filterQueryOptions(options)] as const
+}
+
+export type GetResolverQueryKey<config extends Config> = ReturnType<
+  typeof getResolverQueryKey<config>
+>

package/src/query/public/getSupportedInterfaces.ts

@@ -0,0 +1,80 @@
+import {
+  ASSERT_NO_TYPE_ERROR,
+  type ExcludeTE,
+} from '@ensdomains/ensjs/internal'
+import type { QueryOptions } from '@tanstack/query-core'
+import type { Config } from '@wagmi/core'
+import type {
+  Compute,
+  ExactPartial,
+  ScopeKeyParameter,
+} from '@wagmi/core/internal'
+import type { Chain, Hex } from 'viem'
+import {
+  type GetSupportedInterfacesErrorType,
+  type GetSupportedInterfacesParameters,
+  type GetSupportedInterfacesReturnType,
+  getSupportedInterfaces,
+} from '../../actions/public/getSupportedInterfaces.js'
+import type { RequireConfigContracts } from '../../utils/chain.js'
+import { filterQueryOptions } from '../utils.js'
+
+export type GetSupportedInterfacesOptions<
+  config extends Config,
+  interfaces extends readonly Hex[] = readonly Hex[],
+> = Compute<
+  ExactPartial<GetSupportedInterfacesParameters<config, interfaces>> &
+    ScopeKeyParameter
+>
+
+export function getSupportedInterfacesQueryOptions<
+  chains extends readonly [Chain, ...Chain[]],
+  const interfaces extends readonly Hex[],
+>(
+  config: RequireConfigContracts<chains, 'multicall3'>,
+  options: GetSupportedInterfacesOptions<
+    ExcludeTE<typeof config>,
+    interfaces
+  > = {},
+) {
+  ASSERT_NO_TYPE_ERROR(config)
+
+  return {
+    async queryFn({ queryKey }) {
+      const { address, interfaces, scopeKey: _, ...parameters } = queryKey[1]
+      if (!address) throw new Error('address is required')
+      if (!interfaces) throw new Error('interfaces is required')
+      return getSupportedInterfaces<chains, interfaces>(config, {
+        ...parameters,
+        address,
+        interfaces,
+      })
+    },
+    queryKey: getSupportedInterfacesQueryKey(options),
+  } as const satisfies QueryOptions<
+    GetSupportedInterfacesQueryFnData<interfaces>,
+    GetSupportedInterfacesErrorType,
+    GetSupportedInterfacesData<interfaces>,
+    GetSupportedInterfacesQueryKey<typeof config, interfaces>
+  >
+}
+
+export type GetSupportedInterfacesQueryFnData<
+  interfaces extends readonly Hex[] = readonly Hex[],
+> = GetSupportedInterfacesReturnType<interfaces>
+
+export type GetSupportedInterfacesData<
+  interfaces extends readonly Hex[] = readonly Hex[],
+> = GetSupportedInterfacesQueryFnData<interfaces>
+
+export function getSupportedInterfacesQueryKey<
+  config extends Config,
+  interfaces extends readonly Hex[] = readonly Hex[],
+>(options: GetSupportedInterfacesOptions<config, interfaces> = {}) {
+  return ['ensjs_supportedInterfaces', filterQueryOptions(options)] as const
+}
+
+export type GetSupportedInterfacesQueryKey<
+  config extends Config,
+  interfaces extends readonly Hex[] = readonly Hex[],
+> = ReturnType<typeof getSupportedInterfacesQueryKey<config, interfaces>>