@ensdomains/ensjs 4.1.2 → 5.0.0-alpha.0

package/src/utils/coders/resolverMulticallParameters.ts

@@ -0,0 +1,109 @@
+import type { Hex } from 'viem'
+import type { Prettify } from '../../types/index.js'
+import {
+  type ClearRecordsParametersErrorType,
+  type ClearRecordsParametersReturnType,
+  clearRecordsParameters,
+} from './clearRecords.js'
+import type { EncodeAbiParameters } from './encodeAbi.js'
+import {
+  type SetAbiParametersErrorType,
+  type SetAbiParametersReturnType,
+  setAbiParameters,
+} from './setAbi.js'
+import {
+  type SetAddrParametersErrorType,
+  type SetAddrParametersParameters,
+  type SetAddrParametersReturnType,
+  setAddrParameters,
+} from './setAddr.js'
+import {
+  type SetContentHashParametersErrorType,
+  type SetContentHashParametersReturnType,
+  setContentHashParameters,
+} from './setContentHash.js'
+import {
+  type SetTextParameters,
+  type SetTextParametersErrorType,
+  type SetTextParametersReturnType,
+  setTextParameters,
+} from './setText.js'
+
+export type RecordOptions = Prettify<{
+  /** Clears all current records */
+  clearRecords?: boolean
+  /** ContentHash value */
+  contentHash?: string | null
+  /** Array of text records */
+  texts?: Omit<SetTextParameters, 'namehash'>[]
+  /** Array of coin records */
+  coins?: Omit<SetAddrParametersParameters, 'namehash'>[]
+  /** ABI value */
+  abi?: EncodeAbiParameters | EncodeAbiParameters[]
+}>
+
+export type ResolverMulticallItem =
+  | ClearRecordsParametersReturnType
+  | SetContentHashParametersReturnType
+  | SetAbiParametersReturnType
+  | SetTextParametersReturnType
+  | SetAddrParametersReturnType
+
+// ================================
+// Resolver multicall item
+// ================================
+
+export type ResolverMulticallParametersReturnType = ResolverMulticallItem[]
+
+export type ResolverMulticallItemErrorType =
+  | ClearRecordsParametersErrorType
+  | SetContentHashParametersErrorType
+  | SetAbiParametersErrorType
+  | SetTextParametersErrorType
+  | SetAddrParametersErrorType
+
+export const resolverMulticallParameters = async ({
+  namehash,
+  clearRecords,
+  contentHash,
+  texts,
+  coins,
+  abi,
+}: {
+  namehash: Hex
+} & RecordOptions): Promise<ResolverMulticallParametersReturnType> => {
+  const calls: ResolverMulticallParametersReturnType = []
+
+  if (clearRecords) {
+    calls.push(clearRecordsParameters(namehash))
+  }
+
+  if (contentHash !== undefined) {
+    const data = setContentHashParameters({ namehash, contentHash })
+    if (data) calls.push(data)
+  }
+
+  if (abi !== undefined) {
+    const abis = Array.isArray(abi) ? abi : [abi]
+    const data = await Promise.all(
+      abis.map(async (abiItem) => setAbiParameters({ namehash, ...abiItem })),
+    )
+    if (data) calls.push(...data)
+  }
+
+  if (texts && texts.length > 0) {
+    const data = texts.map((textItem) =>
+      setTextParameters({ namehash, ...textItem }),
+    )
+    if (data) calls.push(...data)
+  }
+
+  if (coins && coins.length > 0) {
+    const data = coins.map((coinItem) =>
+      setAddrParameters({ namehash, ...coinItem }),
+    )
+    if (data) calls.push(...data)
+  }
+
+  return calls
+}

package/src/utils/coders/setAbi.ts

@@ -0,0 +1,44 @@
+import type { EncodeFunctionDataParameters, Hex } from 'viem'
+import { publicResolverSetAbiSnippet } from '../../contracts/publicResolver.js'
+import type { Prettify } from '../../types/index.js'
+import {
+  type AbiEncodeAs,
+  type EncodeAbiErrorType,
+  type EncodeAbiParameters,
+  encodeAbi,
+} from './encodeAbi.js'
+
+// ================================
+// Set ABI parameters
+// ================================
+
+export type SetAbiParameters<encodeAs extends AbiEncodeAs = AbiEncodeAs> =
+  Prettify<
+    {
+      namehash: Hex
+    } & EncodeAbiParameters<encodeAs>
+  >
+
+export type SetAbiParametersErrorType = EncodeAbiErrorType
+
+export const setAbiParameters = async <encodeAs extends AbiEncodeAs>({
+  namehash,
+  data,
+  encodeAs,
+}: SetAbiParameters<encodeAs>) => {
+  const { contentType, encodedData } = await encodeAbi({
+    data,
+    encodeAs,
+  } as EncodeAbiParameters<encodeAs>)
+  return {
+    abi: publicResolverSetAbiSnippet,
+    functionName: 'setABI',
+    args: [namehash, BigInt(contentType), encodedData],
+  } as const satisfies EncodeFunctionDataParameters<
+    typeof publicResolverSetAbiSnippet
+  >
+}
+
+export type SetAbiParametersReturnType = Awaited<
+  ReturnType<typeof setAbiParameters>
+>

package/src/utils/coders/setAddr.ts

@@ -0,0 +1,64 @@
+import {
+  type Address,
+  type BytesToHexErrorType,
+  bytesToHex,
+  type EncodeFunctionDataParameters,
+  type Hex,
+} from 'viem'
+import { dedicatedResolverSetAddrSnippet } from '../../contracts/dedicatedResolver.js'
+import { publicResolverSetAddrSnippet } from '../../contracts/publicResolver.js'
+import type { ErrorType } from '../../errors/utils.js'
+import {
+  type GetCoderFromCoinErrorType,
+  getCoderFromCoin,
+} from '../normalizeCoinId.js'
+
+// ================================
+// Set address parameters
+// ================================
+
+export type SetAddrParametersParameters = {
+  namehash?: Hex
+  coin: string | number
+  value: Address | string | null
+}
+
+export type SetAddrParametersErrorType =
+  | GetCoderFromCoinErrorType
+  | BytesToHexErrorType
+  | ErrorType
+
+export const setAddrParameters = ({
+  namehash,
+  coin,
+  value,
+}: SetAddrParametersParameters) => {
+  const coder = getCoderFromCoin(coin)
+  const inputCoinType = coder.coinType
+  let encodedAddress: Hex | Uint8Array = value ? coder.decode(value) : '0x'
+
+  if (inputCoinType === 60 && encodedAddress === '0x')
+    encodedAddress = coder.decode('0x0000000000000000000000000000000000000000')
+  if (typeof encodedAddress !== 'string') {
+    encodedAddress = bytesToHex(encodedAddress)
+  }
+
+  if (namehash) {
+    return {
+      abi: publicResolverSetAddrSnippet,
+      functionName: 'setAddr',
+      args: [namehash, BigInt(inputCoinType), encodedAddress],
+    } as const satisfies EncodeFunctionDataParameters<
+      typeof publicResolverSetAddrSnippet
+    >
+  }
+  return {
+    abi: dedicatedResolverSetAddrSnippet,
+    functionName: 'setAddr',
+    args: [BigInt(inputCoinType), encodedAddress],
+  } as const satisfies EncodeFunctionDataParameters<
+    typeof dedicatedResolverSetAddrSnippet
+  >
+}
+
+export type SetAddrParametersReturnType = ReturnType<typeof setAddrParameters>

package/src/utils/coders/setContentHash.ts

@@ -0,0 +1,45 @@
+import type { EncodeFunctionDataParameters, Hex } from 'viem'
+import { dedicatedResolverSetContentHashSnippet } from '../../contracts/dedicatedResolver.js'
+import { publicResolverSetContenthashSnippet } from '../../contracts/publicResolver.js'
+import {
+  type EncodeContentHashErrorType,
+  encodeContentHash,
+} from '../contentHash.js'
+
+// ================================
+// Set content hash parameters
+// ================================
+
+export type SetContentHashParameters = {
+  namehash?: Hex
+  contentHash: string | null
+}
+
+export type SetContentHashParametersErrorType = EncodeContentHashErrorType
+
+export const setContentHashParameters = ({
+  namehash,
+  contentHash,
+}: SetContentHashParameters) => {
+  const encodedHash = contentHash ? encodeContentHash(contentHash) : '0x'
+  if (namehash) {
+    return {
+      abi: publicResolverSetContenthashSnippet,
+      functionName: 'setContenthash',
+      args: [namehash, encodedHash],
+    } as const satisfies EncodeFunctionDataParameters<
+      typeof publicResolverSetContenthashSnippet
+    >
+  }
+  return {
+    abi: dedicatedResolverSetContentHashSnippet,
+    functionName: 'setContenthash',
+    args: [encodedHash],
+  } as const satisfies EncodeFunctionDataParameters<
+    typeof dedicatedResolverSetContentHashSnippet
+  >
+}
+
+export type SetContentHashParametersReturnType = ReturnType<
+  typeof setContentHashParameters
+>

package/src/utils/coders/setText.ts

@@ -0,0 +1,40 @@
+import type { EncodeFunctionDataParameters, Hex } from 'viem'
+import { dedicatedResolverSetTextSnippet } from '../../contracts/dedicatedResolver.js'
+import { publicResolverSetTextSnippet } from '../../contracts/publicResolver.js'
+
+// ================================
+// Set text parameters
+// ================================
+
+export type SetTextParameters = {
+  namehash?: Hex
+  key: string
+  value: string | null
+}
+
+export type SetTextParametersErrorType = never
+
+export const setTextParameters = ({
+  namehash,
+  key,
+  value,
+}: SetTextParameters) => {
+  if (namehash) {
+    return {
+      abi: publicResolverSetTextSnippet,
+      functionName: 'setText',
+      args: [namehash, key, value ?? ''],
+    } as const satisfies EncodeFunctionDataParameters<
+      typeof publicResolverSetTextSnippet
+    >
+  }
+  return {
+    abi: dedicatedResolverSetTextSnippet,
+    functionName: 'setText',
+    args: [key, value ?? ''],
+  } as const satisfies EncodeFunctionDataParameters<
+    typeof dedicatedResolverSetTextSnippet
+  >
+}
+
+export type SetTextParametersReturnType = ReturnType<typeof setTextParameters>

package/src/utils/contentHash.ts

@@ -1,11 +1,11 @@
 import {
-  type Codec as InternalCodec,
   decode,
   encode,
   getCodec,
+  type Codec as InternalCodec,
 } from '@ensdomains/content-hash'
 import { type Hex, isHex } from 'viem'
-import { InvalidContentHashError } from '../errors/utils.js'
+import { type ErrorType, InvalidContentHashError } from '../errors/utils.js'
 
 export type ProtocolType =
   | 'ipfs'
@@ -30,7 +30,14 @@ function matchProtocol(text: string) {
   )
 }
 
+// ================================
+// Get display codec
+// ================================
+
+export type GetDisplayCodecErrorType = ErrorType
+
 export const getDisplayCodec = (encoded: string): ProtocolType => {
+  // could throw
   const codec = getCodec(encoded)
   switch (codec) {
     case 'ipfs':
@@ -49,6 +56,12 @@ export const getDisplayCodec = (encoded: string): ProtocolType => {
   }
 }
 
+// ================================
+// Get internal codec
+// ================================
+
+export type GetInternalCodecErrorType = ErrorType
+
 export const getInternalCodec = (
   displayCodec: NonNullable<ProtocolType>,
 ): InternalCodec => {
@@ -64,6 +77,12 @@ export const getInternalCodec = (
   }
 }
 
+// ================================
+// Decode content hash
+// ================================
+
+export type DecodeContentHashErrorType = ErrorType | GetDisplayCodecErrorType
+
 export function decodeContentHash(encoded: Hex): DecodedContentHash | null {
   if (!encoded || encoded === '0x') {
     return null
@@ -73,12 +92,24 @@ export function decodeContentHash(encoded: Hex): DecodedContentHash | null {
   return { protocolType, decoded }
 }
 
+// ================================
+// Is valid content hash
+// ================================
+
+export type IsValidContentHashErrorType = ErrorType | GetDisplayCodecErrorType
+
 export function isValidContentHash(encoded: unknown) {
   if (typeof encoded !== 'string') return false
   const codec = getCodec(encoded)
   return Boolean(codec && isHex(encoded))
 }
 
+// ================================
+// Get protocol type
+// ================================
+
+export type GetProtocolTypeErrorType = ErrorType
+
 export function getProtocolType(encoded: string) {
   const matched = matchProtocol(encoded)
   if (!matched) return null
@@ -86,6 +117,12 @@ export function getProtocolType(encoded: string) {
   return { protocolType: protocolType as NonNullable<ProtocolType>, decoded }
 }
 
+// ================================
+// Encode content hash
+// ================================
+
+export type EncodeContentHashErrorType = ErrorType | GetProtocolTypeErrorType
+
 export function encodeContentHash(text: string): Hex {
   const typeData = getProtocolType(text)
   if (!typeData) throw new InvalidContentHashError()

package/src/utils/dns/getDnsTxtRecords.ts

@@ -1,4 +1,5 @@
-import type { Endpoint } from '../../functions/dns/types.js'
+import type { Endpoint } from '../../actions/dns/types.js'
+import type { ErrorType } from '../../errors/utils.js'
 import type { DnsResponse } from './misc.js'
 
 export type GetDnsTxtRecordsParameters = {
@@ -10,6 +11,8 @@ export type GetDnsTxtRecordsParameters = {
 
 export type GetDnsTxtRecordsReturnType = DnsResponse
 
+export type GetDnsTxtRecordsErrorType = ErrorType
+
 /**
  * Gets the DNS record response of a name, via DNS record lookup
  * @param parameters - {@link GetDnsTxtRecordsParameters}

package/src/utils/errors/isNullRegistrarOwnerOfError.ts

@@ -0,0 +1,12 @@
+import { BaseError, ContractFunctionRevertedError } from 'viem'
+
+/**
+ * Checks if the error is a known revert error for the registrar ownerOf function
+ * @returns `true` if the error is a known revert error, `false` if it is not, or throws if it is an unknown error
+ */
+export const isNullRegistrarOwnerOfError = (err: unknown) => {
+  if (!(err instanceof BaseError)) return false
+  const cause = err.walk((e) => e instanceof ContractFunctionRevertedError)
+  if (!(cause instanceof ContractFunctionRevertedError)) return false
+  return true
+}

package/src/utils/errors/isNullUniversalResolverError.ts

@@ -0,0 +1,19 @@
+import { BaseError, ContractFunctionRevertedError } from 'viem'
+
+/**
+ * Checks if the data returned from a universal resolver is safe to use, or if it is a known revert error
+ * @returns `true` if the data is safe to use, `false` if it is a known revert error, or throws if it is an unknown error
+ */
+export const isNullUniversalResolverError = (err: unknown) => {
+  if (!(err instanceof BaseError)) return false
+  const cause = err.walk((e) => e instanceof ContractFunctionRevertedError)
+  if (!(cause instanceof ContractFunctionRevertedError)) return false
+
+  if (cause.data?.errorName === 'ResolverNotFound') return true
+  if (cause.data?.errorName === 'ResolverWildcardNotSupported') return true
+  if (cause.data?.errorName === 'ResolverNotContract') return true
+  if (cause.data?.errorName === 'ResolverError') return true
+  if (cause.data?.errorName === 'HttpError') return true
+
+  return false
+}

package/src/utils/errors/parseReverseAddressMismatchError.ts

@@ -0,0 +1,14 @@
+import { BaseError, ContractFunctionRevertedError } from 'viem'
+
+/**
+ * Determines whether the error is a `ReverseAddressMismatch` and returns its arguments if so.
+ */
+export const parseReverseAddressMismatchError = (err: unknown) => {
+  if (!(err instanceof BaseError)) return false
+  const cause = err.walk((e) => e instanceof ContractFunctionRevertedError)
+  if (!(cause instanceof ContractFunctionRevertedError)) return false
+
+  if (cause.data?.errorName === 'ReverseAddressMismatch') return cause.data.args
+
+  return false
+}

package/src/utils/fuses.ts

@@ -202,6 +202,12 @@ export type EncodeFusesInputObject =
       number: bigint
     }
 
+// ================================
+// Validate fuse number
+// ================================
+
+type ValidateFuseNumberErrorType = FusesOutOfRangeError
+
 const validateFuseNumber = (fuses: bigint) => {
   if (fuses > 2n ** 32n || fuses < 0n)
     throw new FusesOutOfRangeError({
@@ -218,6 +224,17 @@ const validateFuseNumber = (fuses: bigint) => {
     })
 }
 
+// ================================
+// Check fuse object
+// ================================
+
+type CheckFuseObjectErrorType =
+  | FusesInvalidFuseObjectError
+  | ValidateFuseNumberErrorType
+  | FusesOutOfRangeError
+  | FusesInvalidNamedFuseError
+  | FusesInvalidUnnamedFuseError
+
 const checkFuseObject = <TFuseReference extends GenericFuseEnum>({
   reference,
   object,
@@ -267,7 +284,11 @@ const checkFuseObject = <TFuseReference extends GenericFuseEnum>({
   return Number(fuseNumber)
 }
 
-type EncodeFusesParameters =
+// ================================
+// Encode fuses
+// ================================
+
+export type EncodeFusesParameters =
   | {
       restriction: 'child'
       input: EncodeChildFusesInputObject
@@ -281,6 +302,10 @@ type EncodeFusesParameters =
       input: EncodeFusesInputObject
     }
 
+export type EncodeFusesErrorType =
+  | CheckFuseObjectErrorType
+  | FusesRestrictionNotAllowedError
+
 export const encodeFuses = ({
   restriction,
   input,
@@ -325,6 +350,10 @@ export const encodeFuses = ({
   return Number(childFuses | parentFuses)
 }
 
+// ================================
+// Decode fuses
+// ================================
+
 type DecodedFuseGroup<TFuseReference extends GenericFuseEnum> = {
   [key in TFuseReference['Keys'][number]]: boolean
 } & {

package/src/utils/generateSupportedContentTypes.ts

@@ -1,4 +1,4 @@
-import type { AbiEncodeAs } from './encoders/encodeAbi.js'
+import type { AbiEncodeAs } from './coders/encodeAbi.js'
 
 const abiEncodeAsMap: { [key in AbiEncodeAs]: bigint } = {
   json: 1n,