@ensdomains/ensjs 3.0.0-alpha.9 → 3.0.0-beta.2

package/src/utils/encoders/encodeSetText.ts

@@ -0,0 +1,22 @@
+import { encodeFunctionData, type Hex } from 'viem'
+import { publicResolverSetTextSnippet } from '../../contracts/publicResolver.js'
+
+export type EncodeSetTextParameters = {
+  namehash: Hex
+  key: string
+  value: string | null
+}
+
+export type EncodeSetTextReturnType = Hex
+
+export const encodeSetText = ({
+  namehash,
+  key,
+  value,
+}: EncodeSetTextParameters): EncodeSetTextReturnType => {
+  return encodeFunctionData({
+    abi: publicResolverSetTextSnippet,
+    functionName: 'setText',
+    args: [namehash, key, value ?? ''],
+  })
+}

package/src/utils/format.ts

@@ -1,8 +1,2 @@
-export const formatHashed = (name: string): string =>
-  name.replace(/(\[)(.{64})(\])/g, '0x$2')
-
 export const truncateFormat = (name: string): string =>
   name.replace(/(\[.{3})(.{58})(.{3}\])/g, '$1...$3')
-
-export const bracketFormat = (name: string): string =>
-  name.replace(/(0x)(.{64})(?=\.)/g, '[$2]')

package/src/utils/fuses.ts

@@ -1,23 +1,381 @@
-const CANNOT_UNWRAP = 1
-const CANNOT_BURN_FUSES = 2
-const CANNOT_TRANSFER = 4
-const CANNOT_SET_RESOLVER = 8
-const CANNOT_SET_TTL = 16
-const CANNOT_CREATE_SUBDOMAIN = 32
-const PARENT_CANNOT_CONTROL = 64
-const CAN_DO_EVERYTHING = 0
-
-export const testable = {
-  CANNOT_UNWRAP,
-  CANNOT_BURN_FUSES,
-  CANNOT_TRANSFER,
-  CANNOT_SET_RESOLVER,
-  CANNOT_SET_TTL,
-  CANNOT_CREATE_SUBDOMAIN,
-  PARENT_CANNOT_CONTROL,
-}
-
-export default {
-  ...testable,
-  CAN_DO_EVERYTHING,
+/* eslint-disable @typescript-eslint/no-redeclare, @typescript-eslint/naming-convention  */
+import {
+  FusesInvalidFuseObjectError,
+  FusesInvalidNamedFuseError,
+  FusesInvalidUnnamedFuseError,
+  FusesOutOfRangeError,
+  FusesRestrictionNotAllowedError,
+} from '../errors/utils.js'
+
+export const ChildFuses = {
+  CANNOT_UNWRAP: 1n,
+  CANNOT_BURN_FUSES: 2n,
+  CANNOT_TRANSFER: 4n,
+  CANNOT_SET_RESOLVER: 8n,
+  CANNOT_SET_TTL: 16n,
+  CANNOT_CREATE_SUBDOMAIN: 32n,
+  CANNOT_APPROVE: 64n,
+} as const
+export type ChildFuses = typeof ChildFuses
+export const ChildFuseKeys = Object.keys(ChildFuses) as (keyof ChildFuses)[]
+
+export const ParentFuses = {
+  PARENT_CANNOT_CONTROL: 0x10000n,
+  CAN_EXTEND_EXPIRY: 0x40000n,
+} as const
+export type ParentFuses = typeof ParentFuses
+export const ParentFuseKeys = Object.keys(ParentFuses) as (keyof ParentFuses)[]
+
+export const UserSettableFuses = {
+  ...ChildFuses,
+  ...ParentFuses,
+} as const
+export type UserSettableFuses = typeof UserSettableFuses
+export const UserSettableFuseKeys = Object.keys(
+  UserSettableFuses,
+) as (keyof UserSettableFuses)[]
+
+export const FullParentFuses = {
+  ...ParentFuses,
+  IS_DOT_ETH: 0x20000n,
+} as const
+export type FullParentFuses = typeof FullParentFuses
+export const FullParentFuseKeys = Object.keys(
+  FullParentFuses,
+) as (keyof FullParentFuses)[]
+
+export const UnnamedChildFuses = [
+  0x80n,
+  0x100n,
+  0x200n,
+  0x400n,
+  0x800n,
+  0x1000n,
+  0x2000n,
+  0x4000n,
+  0x8000n,
+] as const
+export type UnnamedChildFuses = typeof UnnamedChildFuses
+export const UnnamedChildFuseKeys = [
+  '0x80',
+  '0x100',
+  '0x200',
+  '0x400',
+  '0x800',
+  '0x1000',
+  '0x2000',
+  '0x4000',
+  '0x8000',
+] as const
+export type UnnamedChildFuseKeys = typeof UnnamedChildFuseKeys
+
+export const UnnamedParentFuses = [
+  0x80000n,
+  0x100000n,
+  0x200000n,
+  0x400000n,
+  0x800000n,
+  0x1000000n,
+  0x2000000n,
+  0x4000000n,
+  0x8000000n,
+  0x10000000n,
+  0x20000000n,
+  0x40000000n,
+  0x80000000n,
+] as const
+export type UnnamedParentFuses = typeof UnnamedParentFuses
+export const UnnamedParentFuseKeys = [
+  '0x80000',
+  '0x100000',
+  '0x200000',
+  '0x400000',
+  '0x800000',
+  '0x1000000',
+] as const
+export type UnnamedParentFuseKeys = typeof UnnamedParentFuseKeys
+
+export const FuseRanges = {
+  CHILD_CONTROLLED_FUSES: 0x0000ffffn,
+  PARENT_CONTROLLED_FUSES: 0xffff0000n,
+  USER_SETTABLE_FUSES: 0xfffdffffn,
+} as const
+
+type FuseRestriction = 'parent' | 'child'
+
+type GenericFuseEnum<TGroupName extends FuseRestriction = FuseRestriction> = {
+  Name: TGroupName
+  Object: Record<string, bigint>
+  Keys: string[]
+  Range: bigint
+  Unnamed: readonly bigint[]
+  UnnamedKeys: readonly string[]
+  Minimum: bigint
+  Maximum: bigint
+}
+
+const ChildReference = {
+  Name: 'child',
+  Object: ChildFuses,
+  Keys: ChildFuseKeys,
+  Range: FuseRanges.CHILD_CONTROLLED_FUSES,
+  Unnamed: UnnamedChildFuses,
+  UnnamedKeys: UnnamedChildFuseKeys,
+  Minimum: 0n,
+  Maximum: 2n ** 16n - 1n,
+} as const
+type ChildReference = typeof ChildReference & {
+  Key: keyof ChildReference['Object']
+  UnnamedKey: ChildReference['Unnamed'][number]
+}
+
+const ParentReference = {
+  Name: 'parent',
+  Object: ParentFuses,
+  Keys: ParentFuseKeys,
+  Range: FuseRanges.PARENT_CONTROLLED_FUSES,
+  Unnamed: UnnamedParentFuses,
+  UnnamedKeys: UnnamedParentFuseKeys,
+  Minimum: 2n ** 16n,
+  Maximum: 2n ** 32n,
+} as const
+type ParentReference = typeof ParentReference & {
+  Key: keyof ParentReference['Object']
+  UnnamedKey: ParentReference['Unnamed'][number]
+}
+
+const FullParentReference = {
+  Name: 'parent',
+  Object: FullParentFuses,
+  Keys: FullParentFuseKeys,
+  Range: FuseRanges.PARENT_CONTROLLED_FUSES,
+  Unnamed: UnnamedParentFuses,
+  UnnamedKeys: UnnamedParentFuseKeys,
+  Minimum: 2n ** 16n,
+  Maximum: 2n ** 32n,
+} as const
+type FullParentReference = typeof FullParentReference & {
+  Key: keyof FullParentReference['Object']
+  UnnamedKey: ParentReference['Unnamed'][number]
+}
+
+type InputFuses<NamedFuse extends string, UnnamedFuse extends bigint> =
+  | {
+      named: readonly NamedFuse[]
+      unnamed?: readonly UnnamedFuse[]
+      number?: never
+    }
+  | {
+      named?: readonly NamedFuse[]
+      unnamed: readonly UnnamedFuse[]
+      number?: never
+    }
+  | {
+      named?: never
+      unnamed?: never
+      number: bigint
+    }
+
+export type EncodeChildFusesInputObject = InputFuses<
+  ChildReference['Key'],
+  ChildReference['UnnamedKey']
+>
+export type EncodeParentFusesInputObject = InputFuses<
+  ParentReference['Key'],
+  ParentReference['UnnamedKey']
+>
+
+export type EncodeFusesInputObject =
+  | {
+      child: EncodeChildFusesInputObject
+      parent?: EncodeParentFusesInputObject
+      number?: never
+    }
+  | {
+      child?: EncodeChildFusesInputObject
+      parent: EncodeParentFusesInputObject
+      number?: never
+    }
+  | {
+      child?: never
+      parent?: never
+      number: bigint
+    }
+
+const validateFuseNumber = (fuses: bigint) => {
+  if (fuses > 2n ** 32n || fuses < 0n)
+    throw new FusesOutOfRangeError({
+      fuses,
+      details: `Fuse number must be limited to uint32, the supplied value was too ${
+        fuses < 0 ? 'low' : 'high'
+      }`,
+    })
+  else if ((fuses & FuseRanges.USER_SETTABLE_FUSES) !== fuses)
+    throw new FusesOutOfRangeError({
+      fuses,
+      details: `Fuse number must be limited to user settable fuses, the supplied value was not`,
+    })
+}
+
+const checkFuseObject = <TFuseReference extends GenericFuseEnum>({
+  reference,
+  object,
+}: {
+  reference: TFuseReference
+  object: EncodeFusesInputObject[TFuseReference['Name']]
+}): number => {
+  if (!object) return 0
+
+  if ('number' in object) {
+    if ('named' in object || 'unnamed' in object)
+      throw new FusesInvalidFuseObjectError({
+        fuses: object,
+        details: 'Cannot specify both a fuse number and named/unnamed fuses.',
+      })
+    validateFuseNumber(object.number)
+
+    if ((object.number & reference.Range) !== object.number)
+      throw new FusesOutOfRangeError({
+        fuses: object.number,
+        minimum: reference.Minimum,
+        maximum: reference.Maximum,
+        details: `Cannot specify a fuse value to set that is outside of the ${reference.Name}'s control.`,
+      })
+
+    return Number(object.number)
+  }
+
+  let fuseNumber = 0n
+
+  if ('named' in object && object.named) {
+    for (const fuse of object.named) {
+      if (!reference.Keys.includes(fuse))
+        throw new FusesInvalidNamedFuseError({ fuse })
+      fuseNumber |= reference.Object[fuse]
+    }
+  }
+
+  if ('unnamed' in object && object.unnamed) {
+    for (const fuse of object.unnamed) {
+      if (!reference.Unnamed.includes(fuse))
+        throw new FusesInvalidUnnamedFuseError({ fuse })
+      fuseNumber |= fuse
+    }
+  }
+
+  return Number(fuseNumber)
 }
+
+type EncodeFusesParameters =
+  | {
+      restriction: 'child'
+      input: EncodeChildFusesInputObject
+    }
+  | {
+      restriction: 'parent'
+      input: EncodeParentFusesInputObject
+    }
+  | {
+      restriction?: never
+      input: EncodeFusesInputObject
+    }
+
+export const encodeFuses = ({
+  restriction,
+  input,
+}: EncodeFusesParameters): number => {
+  if (restriction) {
+    if ('parent' in input || 'child' in input)
+      throw new FusesRestrictionNotAllowedError({
+        fuses: input,
+        details:
+          'Fuse restriction cannot be used when fuse category is specified',
+      })
+    return checkFuseObject({
+      object: input,
+      reference: restriction === 'child' ? ChildReference : ParentReference,
+    })
+  }
+
+  if ('number' in input) {
+    if ('parent' in input || 'child' in input)
+      throw new FusesInvalidFuseObjectError({
+        fuses: input,
+        details: 'Cannot specify both a fuse number and named/unnamed fuses.',
+      })
+
+    validateFuseNumber(input.number)
+    return Number(input.number)
+  }
+
+  const childFuses =
+    'child' in input
+      ? checkFuseObject({ object: input.child, reference: ChildReference })
+      : 0
+  const parentFuses =
+    'parent' in input
+      ? checkFuseObject({ object: input.parent, reference: ParentReference })
+      : 0
+
+  return Number(childFuses | parentFuses)
+}
+
+type DecodedFuseGroup<TFuseReference extends GenericFuseEnum> = {
+  [key in TFuseReference['Keys'][number]]: boolean
+} & {
+  unnamed: {
+    [key in TFuseReference['UnnamedKeys'][number]]: boolean
+  }
+}
+
+type DecodedChildFuses = DecodedFuseGroup<ChildReference> & {
+  CAN_DO_EVERYTHING: boolean
+}
+type DecodedParentFuses = DecodedFuseGroup<FullParentReference>
+
+export type DecodedFuses = {
+  child: DecodedChildFuses
+  parent: DecodedParentFuses
+}
+
+const decodeFusesFromReference = <TFuseReference extends GenericFuseEnum>({
+  input,
+  reference,
+}: {
+  input: bigint
+  reference: TFuseReference
+}): DecodedFuseGroup<TFuseReference> => ({
+  ...(Object.fromEntries(
+    reference.Keys.map((key) => [
+      key,
+      (input & reference.Object[key]) === reference.Object[key],
+    ]),
+  ) as Record<TFuseReference['Keys'][number], boolean>),
+  unnamed: Object.fromEntries(
+    reference.UnnamedKeys.map((key) => [
+      key,
+      (input & BigInt(key)) === BigInt(key),
+    ]),
+  ) as Record<TFuseReference['UnnamedKeys'][number], boolean>,
+})
+
+export const decodeFuses = (fuses: number): DecodedFuses => {
+  const fusesBigInt = BigInt(fuses)
+  return {
+    parent: decodeFusesFromReference({
+      input: fusesBigInt,
+      reference: FullParentReference,
+    }),
+    child: {
+      ...decodeFusesFromReference({
+        input: fusesBigInt,
+        reference: ChildReference,
+      }),
+      CAN_DO_EVERYTHING:
+        (fusesBigInt & FuseRanges.CHILD_CONTROLLED_FUSES) === 0n,
+    },
+  }
+}
+
+export const checkPccBurned = (fuses: bigint) =>
+  (fuses & ParentFuses.PARENT_CANNOT_CONTROL) === 0n

package/src/utils/generateFunction.ts

@@ -0,0 +1,83 @@
+import { BaseError } from 'viem'
+import { call } from 'viem/actions'
+import type { ClientWithEns } from '../contracts/consts.js'
+import type { TransactionRequestWithPassthrough } from '../types.js'
+
+export type EncoderFunction = (
+  ...args: any[]
+) => TransactionRequestWithPassthrough
+export type DecoderFunction = (...args: any[]) => Promise<any>
+
+type OmitFirstArg<F> = F extends (x: any, ...args: infer P) => infer R
+  ? (...args: P) => R
+  : never
+
+export type CoderObject<
+  TEncoderFn extends EncoderFunction = EncoderFunction,
+  TDecoderFn extends DecoderFunction = DecoderFunction,
+> = {
+  encode: TEncoderFn
+  decode: TDecoderFn
+}
+
+export type BatchFunctionResult<
+  TEncoderFn extends EncoderFunction = EncoderFunction,
+  TDecoderFn extends DecoderFunction = DecoderFunction,
+> = {
+  args: Parameters<OmitFirstArg<TEncoderFn>>
+} & CoderObject<TEncoderFn, TDecoderFn>
+
+export type ExtractResult<TFunction extends Function> = TFunction extends (
+  ...args: any[]
+) => Promise<infer U>
+  ? U
+  : never
+
+export interface GeneratedFunction<
+  TEncoderFn extends EncoderFunction,
+  TDecoderFn extends DecoderFunction,
+> extends Function,
+    CoderObject<TEncoderFn, TDecoderFn> {
+  (
+    client: ClientWithEns,
+    ...args: Parameters<OmitFirstArg<TEncoderFn>>
+  ): Promise<ExtractResult<TDecoderFn> | null>
+  batch: (
+    ...args: Parameters<OmitFirstArg<TEncoderFn>>
+  ) => BatchFunctionResult<TEncoderFn, TDecoderFn>
+}
+
+export const generateFunction = <
+  TEncoderFn extends EncoderFunction,
+  TDecoderFn extends DecoderFunction,
+  TFunction extends GeneratedFunction<
+    TEncoderFn,
+    TDecoderFn
+  > = GeneratedFunction<TEncoderFn, TDecoderFn>,
+>({
+  encode,
+  decode,
+}: {
+  encode: TEncoderFn
+  decode: TDecoderFn
+}) => {
+  const single = async function (client, ...args) {
+    const { passthrough, ...encodedData } = encode(client, ...args)
+    const result = await call(client, encodedData)
+      .then((ret) => ret.data)
+      .catch((e) => {
+        if (!(e instanceof BaseError)) throw e
+        return e
+      })
+    if (passthrough) return decode(client, result, passthrough, ...args)
+    return decode(client, result, ...args)
+  } as TFunction
+  single.batch = (...args) => ({
+    args,
+    encode,
+    decode,
+  })
+  single.encode = encode
+  single.decode = decode
+  return single
+}

package/src/utils/generateRecordCallArray.ts

@@ -0,0 +1,76 @@
+import { encodeFunctionData, type Hex } from 'viem'
+import { publicResolverClearRecordsSnippet } from '../contracts/publicResolver.js'
+import type { Prettify } from '../types.js'
+import {
+  encodeSetAbi,
+  type EncodeSetAbiParameters,
+} from './encoders/encodeSetAbi.js'
+import {
+  encodeSetAddr,
+  type EncodeSetAddrParameters,
+} from './encoders/encodeSetAddr.js'
+import { encodeSetContentHash } from './encoders/encodeSetContentHash.js'
+import {
+  encodeSetText,
+  type EncodeSetTextParameters,
+} from './encoders/encodeSetText.js'
+
+export type RecordOptions = Prettify<{
+  /** Clears all current records */
+  clearRecords?: boolean
+  /** ContentHash value */
+  contentHash?: string
+  /** Array of text records */
+  texts?: Omit<EncodeSetTextParameters, 'namehash'>[]
+  /** Array of coin records */
+  coins?: Omit<EncodeSetAddrParameters, 'namehash'>[]
+  /** ABI value */
+  abi?: Omit<EncodeSetAbiParameters, 'namehash'>
+}>
+
+export const generateRecordCallArray = ({
+  namehash,
+  clearRecords,
+  contentHash,
+  texts,
+  coins,
+  abi,
+}: { namehash: Hex } & RecordOptions): Hex[] => {
+  const calls: Hex[] = []
+
+  if (clearRecords) {
+    calls.push(
+      encodeFunctionData({
+        abi: publicResolverClearRecordsSnippet,
+        functionName: 'clearRecords',
+        args: [namehash],
+      }),
+    )
+  }
+
+  if (typeof contentHash === 'string') {
+    const data = encodeSetContentHash({ namehash, contentHash })
+    if (data) calls.push(data)
+  }
+
+  if (abi) {
+    const data = encodeSetAbi({ namehash, ...abi } as EncodeSetAbiParameters)
+    if (data) calls.push(data)
+  }
+
+  if (texts && texts.length > 0) {
+    const data = texts.map((textItem) =>
+      encodeSetText({ namehash, ...textItem }),
+    )
+    if (data) calls.push(...data)
+  }
+
+  if (coins && coins.length > 0) {
+    const data = coins.map((coinItem) =>
+      encodeSetAddr({ namehash, ...coinItem }),
+    )
+    if (data) calls.push(...data)
+  }
+
+  return calls
+}

package/src/utils/getNameType.ts

@@ -0,0 +1,18 @@
+import type { NameType } from '../types.js'
+
+export const getNameType = (name: string): NameType => {
+  const labels = name.split('.')
+  const isDotEth = labels[labels.length - 1] === 'eth'
+
+  if (labels.length === 0) return 'root'
+  if (labels.length === 1) {
+    if (isDotEth) return 'eth-tld'
+    return 'tld'
+  }
+  if (labels.length === 2) {
+    if (isDotEth) return 'eth-2ld'
+    return 'other-2ld'
+  }
+  if (isDotEth) return 'eth-subname'
+  return 'other-subname'
+}

package/src/utils/getRevertErrorData.ts

@@ -0,0 +1,7 @@
+import { BaseError, RawContractError } from 'viem'
+
+export const getRevertErrorData = (err: unknown) => {
+  if (!(err instanceof BaseError)) return undefined
+  const error = err.walk() as RawContractError
+  return typeof error.data === 'object' ? error.data.data : error.data
+}

package/src/utils/hexEncodedName.ts

@@ -1,4 +1,49 @@
-import packet from 'dns-packet'
+// Adapted from https://github.com/mafintosh/dns-packet
+import { bytesToString, labelhash, stringToBytes, type ByteArray } from 'viem'
+import { encodeLabelhash } from './labels.js'
 
-export const hexEncodeName = (name: string) =>
-  `0x${packet.name.encode(name).toString('hex')}`
+/*
+ * @description Encodes a DNS packet into a ByteArray containing a UDP payload.
+ */
+export function packetToBytes(packet: string): ByteArray {
+  // strip leading and trailing `.`
+  const value = packet.replace(/^\.|\.$/gm, '')
+  if (value.length === 0) return new Uint8Array(1)
+
+  const bytes = new Uint8Array(stringToBytes(value).byteLength + 2)
+
+  let offset = 0
+  const list = value.split('.')
+  for (let i = 0; i < list.length; i += 1) {
+    let encoded = stringToBytes(list[i])
+    // if the length is > 255, make the encoded label value a labelhash
+    // this is compatible with the universal resolver
+    if (encoded.byteLength > 255)
+      encoded = stringToBytes(encodeLabelhash(labelhash(list[i])))
+    bytes[offset] = encoded.length
+    bytes.set(encoded, offset + 1)
+    offset += encoded.length + 1
+  }
+
+  if (bytes.byteLength !== offset + 1) return bytes.slice(0, offset + 1)
+
+  return bytes
+}
+
+export function bytesToPacket(bytes: ByteArray): string {
+  let offset = 0
+  let result = ''
+
+  while (offset < bytes.length) {
+    const len = bytes[offset]
+    if (len === 0) {
+      offset += 1
+      break
+    }
+
+    result += `${bytesToString(bytes.subarray(offset + 1, offset + len + 1))}.`
+    offset += len + 1
+  }
+
+  return result.replace(/\.$/, '')
+}