@ensdomains/ensjs-query-core 0.0.1

package/src/query/wallet/registerName.ts

@@ -0,0 +1,54 @@
+import {
+  ASSERT_NO_TYPE_ERROR,
+  type ExcludeTE,
+} from '@ensdomains/ensjs/internal'
+import type { MutationOptions } 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 RegisterNameErrorType,
+  type RegisterNameParameters,
+  type RegisterNameReturnType,
+  registerName,
+} from '../../actions/wallet/registerName.js'
+import type { RequireConfigContracts } from '../../utils/chain.js'
+import { filterQueryOptions } from '../utils.js'
+
+export type RegisterNameOptions<config extends Config> = Compute<
+  ExactPartial<RegisterNameParameters<config>> & ScopeKeyParameter
+>
+
+export function registerNameMutationOptions<
+  chains extends readonly [Chain, ...Chain[]],
+>(
+  config: RequireConfigContracts<chains, 'ensEthRegistrarController'>,
+  options: RegisterNameOptions<ExcludeTE<typeof config>>,
+) {
+  ASSERT_NO_TYPE_ERROR(config)
+
+  return {
+    mutationFn: async (variables: RegisterNameParameters<typeof config>) => {
+      return registerName(config, variables)
+    },
+    mutationKey: registerNameMutationKey(options),
+  } as const satisfies MutationOptions<
+    RegisterNameReturnType,
+    RegisterNameErrorType,
+    RegisterNameParameters<typeof config>
+  >
+}
+
+export function registerNameMutationKey<config extends Config>(
+  options: RegisterNameOptions<config>,
+) {
+  return ['ensjs_registerName', filterQueryOptions(options)] as const
+}
+
+export type RegisterNameMutationKey<config extends Config> = ReturnType<
+  typeof registerNameMutationKey<config>
+>

package/src/query/wallet/renewNames.ts

@@ -0,0 +1,57 @@
+import {
+  ASSERT_NO_TYPE_ERROR,
+  type ExcludeTE,
+} from '@ensdomains/ensjs/internal'
+import type { MutationOptions } 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 RenewNamesErrorType,
+  type RenewNamesParameters,
+  type RenewNamesReturnType,
+  renewNames,
+} from '../../actions/wallet/renewNames.js'
+import type { RequireConfigContracts } from '../../utils/chain.js'
+import { filterQueryOptions } from '../utils.js'
+
+export type RenewNamesOptions<config extends Config> = Compute<
+  ExactPartial<RenewNamesParameters<config>> & ScopeKeyParameter
+>
+
+export function renewNamesMutationOptions<
+  chains extends readonly [Chain, ...Chain[]],
+>(
+  config: RequireConfigContracts<
+    chains,
+    'ensEthRegistrarController' | 'ensBulkRenewal'
+  >,
+  options: RenewNamesOptions<ExcludeTE<typeof config>>,
+) {
+  ASSERT_NO_TYPE_ERROR(config)
+
+  return {
+    mutationFn: async (variables: RenewNamesParameters<typeof config>) => {
+      return renewNames(config, variables)
+    },
+    mutationKey: renewNamesMutationKey(options),
+  } as const satisfies MutationOptions<
+    RenewNamesReturnType,
+    RenewNamesErrorType,
+    RenewNamesParameters<typeof config>
+  >
+}
+
+export function renewNamesMutationKey<config extends Config>(
+  options: RenewNamesOptions<config>,
+) {
+  return ['ensjs_renewNames', filterQueryOptions(options)] as const
+}
+
+export type RenewNamesMutationKey<config extends Config> = ReturnType<
+  typeof renewNamesMutationKey<config>
+>

package/src/query/wallet/setAbiRecord.ts

@@ -0,0 +1,53 @@
+import { ASSERT_NO_TYPE_ERROR } from '@ensdomains/ensjs/internal'
+import type { AbiEncodeAs } from '@ensdomains/ensjs/utils'
+import type { MutationOptions } from '@tanstack/query-core'
+import type { Config } from '@wagmi/core'
+import type {
+  Compute,
+  ExactPartial,
+  ScopeKeyParameter,
+} from '@wagmi/core/internal'
+import {
+  type SetAbiRecordErrorType,
+  type SetAbiRecordParameters,
+  type SetAbiRecordReturnType,
+  setAbiRecord,
+} from '../../actions/wallet/setAbiRecord.js'
+import { filterQueryOptions } from '../utils.js'
+
+export type SetAbiRecordOptions<
+  encodeAs extends AbiEncodeAs,
+  config extends Config,
+> = Compute<
+  ExactPartial<SetAbiRecordParameters<encodeAs, config>> & ScopeKeyParameter
+>
+
+export function setAbiRecordMutationOptions<
+  encodeAs extends AbiEncodeAs,
+  config extends Config,
+>(config: config, options: SetAbiRecordOptions<encodeAs, config>) {
+  ASSERT_NO_TYPE_ERROR(config)
+
+  return {
+    mutationFn: async (variables: SetAbiRecordParameters<encodeAs, config>) => {
+      return setAbiRecord(config, variables)
+    },
+    mutationKey: setAbiRecordMutationKey(options),
+  } as const satisfies MutationOptions<
+    SetAbiRecordReturnType,
+    SetAbiRecordErrorType,
+    SetAbiRecordParameters<encodeAs, config>
+  >
+}
+
+export function setAbiRecordMutationKey<
+  encodeAs extends AbiEncodeAs,
+  config extends Config,
+>(options: SetAbiRecordOptions<encodeAs, config>) {
+  return ['ensjs_setAbiRecord', filterQueryOptions(options)] as const
+}
+
+export type SetAbiRecordMutationKey<
+  encodeAs extends AbiEncodeAs,
+  config extends Config,
+> = ReturnType<typeof setAbiRecordMutationKey<encodeAs, config>>

package/src/query/wallet/setAddressRecord.ts

@@ -0,0 +1,50 @@
+import {
+  ASSERT_NO_TYPE_ERROR,
+  type ExcludeTE,
+} from '@ensdomains/ensjs/internal'
+import type { MutationOptions } from '@tanstack/query-core'
+import type { Config } from '@wagmi/core'
+import type {
+  Compute,
+  ExactPartial,
+  ScopeKeyParameter,
+} from '@wagmi/core/internal'
+import {
+  type SetAddressRecordErrorType,
+  type SetAddressRecordParameters,
+  type SetAddressRecordReturnType,
+  setAddressRecord,
+} from '../../actions/wallet/setAddressRecord.js'
+import { filterQueryOptions } from '../utils.js'
+
+export type SetAddressRecordOptions<config extends Config> = Compute<
+  ExactPartial<SetAddressRecordParameters<config>> & ScopeKeyParameter
+>
+
+export function setAddressRecordMutationOptions<config extends Config>(
+  config: config,
+  options: SetAddressRecordOptions<ExcludeTE<typeof config>>,
+) {
+  ASSERT_NO_TYPE_ERROR(config)
+
+  return {
+    mutationFn: async (variables: SetAddressRecordParameters<config>) => {
+      return setAddressRecord(config, variables)
+    },
+    mutationKey: setAddressRecordMutationKey(options),
+  } as const satisfies MutationOptions<
+    SetAddressRecordReturnType,
+    SetAddressRecordErrorType,
+    SetAddressRecordParameters<config>
+  >
+}
+
+export function setAddressRecordMutationKey<config extends Config>(
+  options: SetAddressRecordOptions<config>,
+) {
+  return ['ensjs_setAddressRecord', filterQueryOptions(options)] as const
+}
+
+export type SetAddressRecordMutationKey<config extends Config> = ReturnType<
+  typeof setAddressRecordMutationKey<config>
+>

package/src/query/wallet/setContentHashRecord.ts

@@ -0,0 +1,50 @@
+import {
+  ASSERT_NO_TYPE_ERROR,
+  type ExcludeTE,
+} from '@ensdomains/ensjs/internal'
+import type { MutationOptions } from '@tanstack/query-core'
+import type { Config } from '@wagmi/core'
+import type {
+  Compute,
+  ExactPartial,
+  ScopeKeyParameter,
+} from '@wagmi/core/internal'
+import {
+  type SetContentHashRecordErrorType,
+  type SetContentHashRecordParameters,
+  type SetContentHashRecordReturnType,
+  setContentHashRecord,
+} from '../../actions/wallet/setContentHashRecord.js'
+import { filterQueryOptions } from '../utils.js'
+
+export type SetContentHashRecordOptions<config extends Config> = Compute<
+  ExactPartial<SetContentHashRecordParameters<config>> & ScopeKeyParameter
+>
+
+export function setContentHashRecordMutationOptions<config extends Config>(
+  config: config,
+  options: SetContentHashRecordOptions<ExcludeTE<typeof config>>,
+) {
+  ASSERT_NO_TYPE_ERROR(config)
+
+  return {
+    mutationFn: async (variables: SetContentHashRecordParameters<config>) => {
+      return setContentHashRecord(config, variables)
+    },
+    mutationKey: setContentHashRecordMutationKey(options),
+  } as const satisfies MutationOptions<
+    SetContentHashRecordReturnType,
+    SetContentHashRecordErrorType,
+    SetContentHashRecordParameters<config>
+  >
+}
+
+export function setContentHashRecordMutationKey<config extends Config>(
+  options: SetContentHashRecordOptions<config>,
+) {
+  return ['ensjs_setContentHashRecord', filterQueryOptions(options)] as const
+}
+
+export type SetContentHashRecordMutationKey<config extends Config> = ReturnType<
+  typeof setContentHashRecordMutationKey<config>
+>

package/src/query/wallet/setPrimaryName.ts

@@ -0,0 +1,57 @@
+import {
+  ASSERT_NO_TYPE_ERROR,
+  type ExcludeTE,
+} from '@ensdomains/ensjs/internal'
+import type { MutationOptions } 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 SetPrimaryNameErrorType,
+  type SetPrimaryNameParameters,
+  type SetPrimaryNameReturnType,
+  setPrimaryName,
+} from '../../actions/wallet/setPrimaryName.js'
+import type { RequireConfigContracts } from '../../utils/chain.js'
+import { filterQueryOptions } from '../utils.js'
+
+export type SetPrimaryNameOptions<config extends Config> = Compute<
+  ExactPartial<SetPrimaryNameParameters<config>> & ScopeKeyParameter
+>
+
+export function setPrimaryNameMutationOptions<
+  chains extends readonly [Chain, ...Chain[]],
+>(
+  config: RequireConfigContracts<
+    chains,
+    'ensPublicResolver' | 'ensReverseRegistrar'
+  >,
+  options: SetPrimaryNameOptions<ExcludeTE<typeof config>>,
+) {
+  ASSERT_NO_TYPE_ERROR(config)
+
+  return {
+    mutationFn: async (variables: SetPrimaryNameParameters<typeof config>) => {
+      return setPrimaryName(config, variables)
+    },
+    mutationKey: setPrimaryNameMutationKey(options),
+  } as const satisfies MutationOptions<
+    SetPrimaryNameReturnType,
+    SetPrimaryNameErrorType,
+    SetPrimaryNameParameters<typeof config>
+  >
+}
+
+export function setPrimaryNameMutationKey<config extends Config>(
+  options: SetPrimaryNameOptions<config>,
+) {
+  return ['ensjs_setPrimaryName', filterQueryOptions(options)] as const
+}
+
+export type SetPrimaryNameMutationKey<config extends Config> = ReturnType<
+  typeof setPrimaryNameMutationKey<config>
+>

package/src/query/wallet/setRecords.ts

@@ -0,0 +1,54 @@
+import {
+  ASSERT_NO_TYPE_ERROR,
+  type ExcludeTE,
+} from '@ensdomains/ensjs/internal'
+import type { MutationOptions } 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 SetRecordsErrorType,
+  type SetRecordsParameters,
+  type SetRecordsReturnType,
+  setRecords,
+} from '../../actions/wallet/setRecords.js'
+import type { RequireConfigContracts } from '../../utils/chain.js'
+import { filterQueryOptions } from '../utils.js'
+
+export type SetRecordsOptions<config extends Config> = Compute<
+  ExactPartial<SetRecordsParameters<config>> & ScopeKeyParameter
+>
+
+export function setRecordsMutationOptions<
+  chains extends readonly [Chain, ...Chain[]],
+>(
+  config: RequireConfigContracts<chains, 'ensPublicResolver'>,
+  options: SetRecordsOptions<ExcludeTE<typeof config>>,
+) {
+  ASSERT_NO_TYPE_ERROR(config)
+
+  return {
+    mutationFn: async (variables: SetRecordsParameters<typeof config>) => {
+      return setRecords(config, variables)
+    },
+    mutationKey: setRecordsMutationKey(options),
+  } as const satisfies MutationOptions<
+    SetRecordsReturnType,
+    SetRecordsErrorType,
+    SetRecordsParameters<typeof config>
+  >
+}
+
+export function setRecordsMutationKey<config extends Config>(
+  options: SetRecordsOptions<config>,
+) {
+  return ['ensjs_setRecords', filterQueryOptions(options)] as const
+}
+
+export type SetRecordsMutationKey<config extends Config> = ReturnType<
+  typeof setRecordsMutationKey<config>
+>

package/src/query/wallet/setResolver.ts

@@ -0,0 +1,54 @@
+import {
+  ASSERT_NO_TYPE_ERROR,
+  type ExcludeTE,
+} from '@ensdomains/ensjs/internal'
+import type { MutationOptions } 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 SetResolverErrorType,
+  type SetResolverParameters,
+  type SetResolverReturnType,
+  setResolver,
+} from '../../actions/wallet/setResolver.js'
+import type { RequireConfigContracts } from '../../utils/chain.js'
+import { filterQueryOptions } from '../utils.js'
+
+export type SetResolverOptions<config extends Config> = Compute<
+  ExactPartial<SetResolverParameters<config>> & ScopeKeyParameter
+>
+
+export function setResolverMutationOptions<
+  chains extends readonly [Chain, ...Chain[]],
+>(
+  config: RequireConfigContracts<chains, 'ensRegistry' | 'ensNameWrapper'>,
+  options: SetResolverOptions<ExcludeTE<typeof config>>,
+) {
+  ASSERT_NO_TYPE_ERROR(config)
+
+  return {
+    mutationFn: async (variables: SetResolverParameters<typeof config>) => {
+      return setResolver(config, variables)
+    },
+    mutationKey: setResolverMutationKey(options),
+  } as const satisfies MutationOptions<
+    SetResolverReturnType,
+    SetResolverErrorType,
+    SetResolverParameters<typeof config>
+  >
+}
+
+export function setResolverMutationKey<config extends Config>(
+  options: SetResolverOptions<config>,
+) {
+  return ['ensjs_setResolver', filterQueryOptions(options)] as const
+}
+
+export type SetResolverMutationKey<config extends Config> = ReturnType<
+  typeof setResolverMutationKey<config>
+>

package/src/query/wallet/setTextRecord.ts

@@ -0,0 +1,50 @@
+import {
+  ASSERT_NO_TYPE_ERROR,
+  type ExcludeTE,
+} from '@ensdomains/ensjs/internal'
+import type { MutationOptions } from '@tanstack/query-core'
+import type { Config } from '@wagmi/core'
+import type {
+  Compute,
+  ExactPartial,
+  ScopeKeyParameter,
+} from '@wagmi/core/internal'
+import {
+  type SetTextRecordErrorType,
+  type SetTextRecordParameters,
+  type SetTextRecordReturnType,
+  setTextRecord,
+} from '../../actions/wallet/setTextRecord.js'
+import { filterQueryOptions } from '../utils.js'
+
+export type SetTextRecordOptions<config extends Config> = Compute<
+  ExactPartial<SetTextRecordParameters<config>> & ScopeKeyParameter
+>
+
+export function setTextRecordMutationOptions<config extends Config>(
+  config: config,
+  options: SetTextRecordOptions<ExcludeTE<typeof config>>,
+) {
+  ASSERT_NO_TYPE_ERROR(config)
+
+  return {
+    mutationFn: async (variables: SetTextRecordParameters<config>) => {
+      return setTextRecord(config, variables)
+    },
+    mutationKey: setTextRecordMutationKey(options),
+  } as const satisfies MutationOptions<
+    SetTextRecordReturnType,
+    SetTextRecordErrorType,
+    SetTextRecordParameters<config>
+  >
+}
+
+export function setTextRecordMutationKey<config extends Config>(
+  options: SetTextRecordOptions<config>,
+) {
+  return ['ensjs_setTextRecord', filterQueryOptions(options)] as const
+}
+
+export type SetTextRecordMutationKey<config extends Config> = ReturnType<
+  typeof setTextRecordMutationKey<config>
+>

package/src/query/wallet/transferName.ts

@@ -0,0 +1,66 @@
+import {
+  ASSERT_NO_TYPE_ERROR,
+  type ExcludeTE,
+} from '@ensdomains/ensjs/internal'
+import type { TransferNameSupportedContract } from '@ensdomains/ensjs/wallet'
+import type { MutationOptions } from '@tanstack/query-core'
+import type { Config } from '@wagmi/core'
+import type {
+  Compute,
+  ExactPartial,
+  ScopeKeyParameter,
+} from '@wagmi/core/internal'
+import type { Chain } from 'viem/chains'
+import {
+  type TransferNameErrorType,
+  type TransferNameParameters,
+  type TransferNameReturnType,
+  transferName,
+} from '../../actions/wallet/transferName.js'
+import type { RequireConfigContracts } from '../../utils/chain.js'
+import { filterQueryOptions } from '../utils.js'
+
+export type TransferNameOptions<
+  contract extends TransferNameSupportedContract,
+  config extends Config,
+> = Compute<
+  ExactPartial<TransferNameParameters<contract, config>> & ScopeKeyParameter
+>
+
+export function transferNameMutationOptions<
+  contract extends TransferNameSupportedContract,
+  chains extends readonly [Chain, ...Chain[]],
+>(
+  config: RequireConfigContracts<
+    chains,
+    'ensRegistry' | 'ensNameWrapper' | 'ensBaseRegistrarImplementation'
+  >,
+  options: TransferNameOptions<contract, ExcludeTE<typeof config>>,
+) {
+  ASSERT_NO_TYPE_ERROR(config)
+
+  return {
+    mutationFn: async (
+      variables: TransferNameParameters<contract, typeof config>,
+    ) => {
+      return transferName(config, variables)
+    },
+    mutationKey: transferNameMutationKey(options),
+  } as const satisfies MutationOptions<
+    TransferNameReturnType,
+    TransferNameErrorType,
+    TransferNameParameters<contract, typeof config>
+  >
+}
+
+export function transferNameMutationKey<
+  contract extends TransferNameSupportedContract,
+  config extends Config,
+>(options: TransferNameOptions<contract, config>) {
+  return ['ensjs_transferName', filterQueryOptions(options)] as const
+}
+
+export type TransferNameMutationKey<
+  contract extends TransferNameSupportedContract,
+  config extends Config,
+> = ReturnType<typeof transferNameMutationKey<contract, config>>

package/src/utils/chain.ts

@@ -0,0 +1,50 @@
+import type { SupportedL1Contract } from '@ensdomains/ensjs/chain'
+import type {
+  StringConcatenationOrder,
+  // biome-ignore lint/suspicious/noShadowRestrictedNames: import
+  TypeError,
+} from '@ensdomains/ensjs/internal'
+import type { Config, CreateConnectorFn, Transport } from '@wagmi/core'
+import type { ChainContract } from 'viem'
+import type { Chain } from 'viem/chains'
+
+export type BaseChainContracts = {
+  [key in keyof NonNullable<Chain['contracts']> as string extends key
+    ? never
+    : key]: NonNullable<Chain['contracts']>[key]
+}
+
+type SuggestedContracts =
+  | SupportedL1Contract
+  | keyof BaseChainContracts
+  | (string & {})
+
+export type RequireConfigContracts<
+  chains extends readonly [Chain, ...Chain[]],
+  contracts extends SuggestedContracts,
+  transports extends Record<chains[number]['id'], Transport> = Record<
+    chains[number]['id'],
+    Transport
+  >,
+  connectorFns extends
+    readonly CreateConnectorFn[] = readonly CreateConnectorFn[],
+> = chains[number] extends Chain & {
+  contracts: {
+    [key in contracts]: ChainContract
+  }
+}
+  ? Config<chains, transports, connectorFns>
+  : TypeError<`One of the "${chains[number]['name']}" chains are missing a required contract: ${StringConcatenationOrder<contracts, ', '>}`>
+
+export type RequireConfigContracts2<
+  config extends Config,
+  contracts extends SupportedL1Contract,
+> = config extends Config<infer chains, infer transports, infer connectorFns>
+  ? chains[number] extends Chain & {
+      contracts: {
+        [key in contracts]: ChainContract
+      }
+    }
+    ? Config<chains, transports, connectorFns>
+    : TypeError<`One of the "${chains[number]['name']}" chains are missing a required contract: ${StringConcatenationOrder<contracts, ', '>}`>
+  : TypeError<`Invalid config`>

package/src/utils/getAction.ts

@@ -0,0 +1,56 @@
+// Source: https://github.com/wevm/wagmi/blob/main/packages/core/src/utils/getAction.ts
+
+import type { EnsPublicActions, EnsWalletActions } from '@ensdomains/ensjs'
+import type {
+  ChainWithContracts,
+  SupportedL1Contract,
+} from '@ensdomains/ensjs/chain'
+import type {
+  Account,
+  Chain,
+  Client,
+  // PublicActions,
+  RpcSchema,
+  Transport,
+  // WalletActions,
+} from 'viem'
+
+/**
+ * Retrieves and returns an action from the client (if exists), and falls
+ * back to the tree-shakable action.
+ *
+ * Useful for extracting overridden actions from a client (ie. if a consumer
+ * wants to override the `sendTransaction` implementation).
+ */
+export function getAction<
+  transport extends Transport,
+  chain extends Chain,
+  account extends Account | undefined,
+  rpcSchema extends RpcSchema | undefined,
+  extended extends { [key: string]: unknown },
+  client extends Client<transport, chain, account, rpcSchema, extended>,
+  parameters,
+  returnType,
+>(
+  client: client,
+  actionFn: (_: any, parameters: parameters) => returnType,
+  // Some minifiers drop `Function.prototype.name`, or replace it with short letters,
+  // meaning that `actionFn.name` will not always work. For that case, the consumer
+  // needs to pass the name explicitly.
+  name:
+    | keyof EnsPublicActions
+    | keyof EnsWalletActions<
+        ChainWithContracts<SupportedL1Contract>,
+        NonNullable<account>
+      >,
+): (parameters: parameters) => returnType {
+  const action_implicit = client[actionFn.name]
+  if (typeof action_implicit === 'function')
+    return action_implicit as (params: parameters) => returnType
+
+  const action_explicit = client[name]
+  if (typeof action_explicit === 'function')
+    return action_explicit as (params: parameters) => returnType
+
+  return (params) => actionFn(client, params)
+}