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

package/src/utils/fuses.ts

@@ -1,23 +1,381 @@
+import {
+  FusesFuseNotAllowedError,
+  FusesInvalidFuseObjectError,
+  FusesInvalidNamedFuseError,
+  FusesInvalidUnnamedFuseError,
+  FusesNonIntegerError,
+  FusesOutOfRangeError,
+  FusesRestrictionNotAllowedError,
+  FusesValueRequiredError,
+} from '../errors/utils.js'
+
+// child named fuses
 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 CANNOT_APPROVE = 64
+
+// parent named fuses
+const PARENT_CANNOT_CONTROL = 0x10000
+const IS_DOT_ETH = 0x20000
+const CAN_EXTEND_EXPIRY = 0x40000
+
+// fuse ranges
+export const CHILD_CONTROLLED_FUSES = 0x0000ffff
+export const PARENT_CONTROLLED_FUSES = 0xffff0000
+export const USER_SETTABLE_FUSES = 0xfffdffff
+
+// empty fuse
 const CAN_DO_EVERYTHING = 0
 
-export const testable = {
+export const childFuseEnum = {
   CANNOT_UNWRAP,
   CANNOT_BURN_FUSES,
   CANNOT_TRANSFER,
   CANNOT_SET_RESOLVER,
   CANNOT_SET_TTL,
   CANNOT_CREATE_SUBDOMAIN,
+  CANNOT_APPROVE,
+} as const
+
+export const parentFuseEnum = {
   PARENT_CANNOT_CONTROL,
+  CAN_EXTEND_EXPIRY,
 }
 
-export default {
-  ...testable,
+export const fullParentFuseEnum = {
+  ...parentFuseEnum,
+  IS_DOT_ETH,
+} as const
+
+export const userSettableFuseEnum = {
+  ...childFuseEnum,
+  ...parentFuseEnum,
+} as const
+
+export const fullFuseEnum = {
+  ...userSettableFuseEnum,
+  ...fullParentFuseEnum,
   CAN_DO_EVERYTHING,
 }
+
+export const unnamedChildFuses = [
+  128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768,
+] as const
+
+export const unnamedParentFuses = [
+  0x80000, 0x100000, 0x200000, 0x400000, 0x800000, 0x1000000, 0x2000000,
+  0x4000000, 0x8000000, 0x10000000, 0x20000000, 0x40000000, 0x80000000,
+] as const
+
+export const unnamedUserSettableFuses = [
+  ...unnamedChildFuses,
+  ...unnamedParentFuses,
+] as const
+
+export const childFuseKeys = Object.keys(
+  childFuseEnum,
+) as (keyof typeof childFuseEnum)[]
+export const parentFuseKeys = Object.keys(
+  parentFuseEnum,
+) as (keyof typeof parentFuseEnum)[]
+export const fullParentFuseKeys = Object.keys(
+  fullParentFuseEnum,
+) as (keyof typeof fullParentFuseEnum)[]
+export const userSettableFuseKeys = Object.keys(
+  userSettableFuseEnum,
+) as (keyof typeof userSettableFuseEnum)[]
+
+type FuseType<
+  Enum extends Record<string, number>,
+  UnnamedTuple extends readonly number[],
+  CustomFuses extends string = never,
+> = {
+  fuse: keyof Enum
+  options: { -readonly [K in keyof Enum]?: boolean }
+  current: { [K in keyof Enum]: boolean } & {
+    readonly [K in CustomFuses]: boolean
+  }
+  unnamed: UnnamedTuple
+  unnamedValues: UnnamedTuple[number]
+  unnamedObject: { [K in UnnamedTuple[number]]: boolean }
+}
+
+export type ChildFuses = FuseType<
+  typeof childFuseEnum,
+  typeof unnamedChildFuses,
+  'CAN_DO_EVERYTHING'
+>
+export type ParentFuses = FuseType<
+  typeof parentFuseEnum,
+  typeof unnamedParentFuses
+>
+export type FullParentFuses = FuseType<
+  typeof fullParentFuseEnum,
+  typeof unnamedParentFuses
+>
+export type UserSettableFuses = FuseType<
+  typeof userSettableFuseEnum,
+  typeof unnamedUserSettableFuses
+>
+
+type InputFuses<NamedFuse extends string, UnnamedFuse extends number> =
+  | {
+      named: readonly NamedFuse[]
+    }
+  | {
+      unnamed: readonly UnnamedFuse[]
+    }
+  | {
+      named: readonly NamedFuse[]
+      unnamed: readonly UnnamedFuse[]
+    }
+  | {
+      number: number
+    }
+
+export type CombinedFuseInput = {
+  child: InputFuses<ChildFuses['fuse'], ChildFuses['unnamedValues']>
+  parent: InputFuses<ParentFuses['fuse'], ParentFuses['unnamedValues']>
+}
+
+type FuseRestriction = 'parent' | 'child'
+
+const checkNumber = (fuses: number) => {
+  if (fuses > 2 ** 32 || fuses < 1)
+    throw new FusesOutOfRangeError({
+      fuses,
+      details: `Fuse number must be limited to uint32, the supplied value was too ${
+        fuses < 1 ? 'low' : 'high'
+      }`,
+    })
+  else if (fuses % 1 !== 0) throw new FusesNonIntegerError({ fuses })
+  else if ((fuses & USER_SETTABLE_FUSES) !== fuses)
+    throw new FusesOutOfRangeError({
+      fuses,
+      maximum: 2 ** 16,
+      details: `Fuse number must be limited to user settable fuses, the supplied value was not`,
+    })
+}
+
+const testFuses = (fuses: any) => {
+  if ('named' in fuses && fuses.named.length > 0) {
+    return true
+  }
+  if ('unnamed' in fuses && fuses.unnamed.length > 0) {
+    return true
+  }
+  if ('number' in fuses && fuses.number !== 0) {
+    return true
+  }
+  return false
+}
+
+export const hasFuses = (fuses: any) => {
+  if (typeof fuses === 'number') {
+    return fuses !== 0
+  }
+
+  if (typeof fuses === 'object') {
+    if ('child' in fuses && testFuses(fuses.child)) {
+      return true
+    }
+    if ('parent' in fuses && testFuses(fuses.parent)) {
+      return true
+    }
+    if (testFuses(fuses)) {
+      return true
+    }
+  }
+  return false
+}
+
+export function encodeFuses(fuses: Partial<CombinedFuseInput> | number): number
+export function encodeFuses(
+  fuses: CombinedFuseInput['child'],
+  restrictTo: 'child',
+): number
+export function encodeFuses(
+  fuses: CombinedFuseInput['parent'],
+  restrictTo: 'parent',
+): number
+export function encodeFuses<T extends FuseRestriction>(
+  fuses: CombinedFuseInput[T],
+  restrictTo?: T,
+) {
+  let encodedFuses: number = 0
+
+  if (typeof fuses === 'number') {
+    if (restrictTo)
+      throw new FusesRestrictionNotAllowedError({
+        fuses,
+        details:
+          'Fuse restriction cannot be used when an exact value is specified',
+      })
+    checkNumber(fuses)
+
+    encodedFuses = fuses
+  } else {
+    let fusesRef = fuses as unknown as CombinedFuseInput
+    let allowedNamed: readonly UserSettableFuses['fuse'][] = []
+    let allowedUnnamed: readonly UserSettableFuses['unnamedValues'][] = []
+
+    let namedArray: readonly UserSettableFuses['fuse'][] = []
+    let unnamedArray: readonly UserSettableFuses['unnamedValues'][] = []
+
+    if (restrictTo) {
+      if ('parent' in fuses || 'child' in fuses)
+        throw new FusesRestrictionNotAllowedError({
+          fuses,
+          details:
+            'Fuse restriction cannot be used when fuse category is specified',
+        })
+      allowedNamed = restrictTo === 'child' ? childFuseKeys : parentFuseKeys
+      allowedUnnamed =
+        restrictTo === 'child' ? unnamedChildFuses : unnamedParentFuses
+
+      fusesRef = { [restrictTo]: fuses } as unknown as CombinedFuseInput
+    } else {
+      allowedNamed = userSettableFuseKeys
+      allowedUnnamed = unnamedUserSettableFuses
+    }
+    if ('parent' in fusesRef) {
+      if ('named' in fusesRef.parent) namedArray = fusesRef.parent.named
+      if ('unnamed' in fusesRef.parent) unnamedArray = fusesRef.parent.unnamed
+      if ('number' in fusesRef.parent) {
+        if ('named' in fusesRef.parent || 'unnamed' in fusesRef.parent)
+          throw new FusesInvalidFuseObjectError({
+            fuses,
+            details:
+              'Cannot specify both a fuse number and named/unnamed fuses.',
+          })
+        checkNumber(fusesRef.parent.number)
+
+        if (
+          (fusesRef.parent.number & PARENT_CONTROLLED_FUSES) !==
+          fusesRef.parent.number
+        )
+          throw new FusesOutOfRangeError({
+            fuses: fusesRef.parent.number,
+            minimum: 2 ** 17,
+            details:
+              "Cannot specify a fuse value to set that is outside of the parent's control.",
+          })
+
+        encodedFuses |= fusesRef.parent.number
+      }
+    }
+    if ('child' in fusesRef) {
+      if ('named' in fusesRef.child)
+        namedArray = [...namedArray, ...fusesRef.child.named]
+      if ('unnamed' in fusesRef.child)
+        unnamedArray = [...unnamedArray, ...fusesRef.child.unnamed]
+      if ('number' in fusesRef.child) {
+        if ('named' in fusesRef.child || 'unnamed' in fusesRef.child)
+          throw new FusesInvalidFuseObjectError({
+            fuses,
+            details:
+              'Cannot specify both a fuse number and named/unnamed fuses.',
+          })
+        checkNumber(fusesRef.child.number)
+
+        if (
+          (fusesRef.child.number & CHILD_CONTROLLED_FUSES) !==
+          fusesRef.child.number
+        )
+          throw new FusesOutOfRangeError({
+            fuses: fusesRef.child.number,
+            maximum: 2 ** 16,
+            details:
+              "Cannot specify a fuse value to set that is outside of the owner's control.",
+          })
+
+        encodedFuses |= fusesRef.child.number
+      }
+    }
+
+    if (!namedArray.length && !unnamedArray.length && !encodedFuses)
+      throw new FusesValueRequiredError()
+
+    for (const fuse of namedArray) {
+      if (!allowedNamed.includes(fuse)) {
+        if (!userSettableFuseKeys.includes(fuse))
+          throw new FusesInvalidNamedFuseError({ fuse })
+        throw new FusesFuseNotAllowedError({ fuse })
+      }
+      encodedFuses |= userSettableFuseEnum[fuse]
+    }
+    for (const fuse of unnamedArray) {
+      if (!allowedUnnamed.includes(fuse)) {
+        if (!unnamedUserSettableFuses.includes(fuse))
+          throw new FusesInvalidUnnamedFuseError({ fuse })
+        throw new FusesFuseNotAllowedError({ fuse })
+      }
+      encodedFuses |= fuse
+    }
+  }
+
+  return encodedFuses
+}
+
+const decodeNamedFuses = (fuses: number, arr: readonly string[]) => {
+  const fuseObj = Object.fromEntries(
+    arr.map((fuse) => [
+      fuse,
+      (fuses & fullFuseEnum[fuse as keyof typeof fullFuseEnum]) ===
+        fullFuseEnum[fuse as keyof typeof fullFuseEnum],
+    ]),
+  )
+
+  return fuseObj
+}
+
+const decodeUnnamedFuses = (fuses: number, arr: readonly number[]) => {
+  const fuseObj = Object.fromEntries(
+    arr.map((fuse) => [fuse, (fuses & fuse) === fuse]),
+  )
+
+  return fuseObj
+}
+
+export const decodeFuses = (fuses: number) => {
+  const parentNamedFuses = decodeNamedFuses(
+    fuses,
+    fullParentFuseKeys,
+  ) as FullParentFuses['current']
+  const parentUnnamedFuses = decodeUnnamedFuses(
+    fuses,
+    unnamedParentFuses,
+  ) as ParentFuses['unnamedObject']
+
+  const childNamedFuses = decodeNamedFuses(
+    fuses,
+    childFuseKeys,
+  ) as ChildFuses['current']
+  const childUnnamedFuses = decodeUnnamedFuses(
+    fuses,
+    unnamedChildFuses,
+  ) as ChildFuses['unnamedObject']
+
+  return {
+    parent: {
+      ...parentNamedFuses,
+      unnamed: parentUnnamedFuses,
+    },
+    child: {
+      ...childNamedFuses,
+      CAN_DO_EVERYTHING: (fuses & CHILD_CONTROLLED_FUSES) === 0,
+      unnamed: childUnnamedFuses,
+    },
+  }
+}
+
+export const checkPCCBurned = (fuses: number) =>
+  (fuses & PARENT_CANNOT_CONTROL) === PARENT_CANNOT_CONTROL
+
+export type AllCurrentFuses = ReturnType<typeof decodeFuses>
+
+export default fullFuseEnum

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.test.ts

@@ -0,0 +1,84 @@
+import { generateRecordCallArray } from './generateRecordCallArray.js'
+import { namehash } from './normalise.js'
+
+it('generates a record call array', () => {
+  expect(
+    generateRecordCallArray({
+      namehash: namehash('test.eth'),
+      clearRecords: true,
+      coins: [
+        { coin: 'ETH', value: '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266' },
+      ],
+
+      texts: [{ key: 'email', value: 'test@example.com' }],
+    }),
+  ).toMatchInlineSnapshot(`
+    [
+      "0x3603d758eb4f647bea6caa36333c816d7b46fdcb05f9466ecacc140ea8c66faf15b3d9f1",
+      "0x10f13a8ceb4f647bea6caa36333c816d7b46fdcb05f9466ecacc140ea8c66faf15b3d9f1000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000005656d61696c000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001074657374406578616d706c652e636f6d00000000000000000000000000000000",
+      "0x8b95dd71eb4f647bea6caa36333c816d7b46fdcb05f9466ecacc140ea8c66faf15b3d9f1000000000000000000000000000000000000000000000000000000000000003c00000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000014f39fd6e51aad88f6f4ce6ab8827279cfffb92266000000000000000000000000",
+    ]
+  `)
+})
+it('adds clearRecords call when clearRecords is true', () => {
+  expect(
+    generateRecordCallArray({
+      namehash: namehash('test.eth'),
+      clearRecords: true,
+    }),
+  ).toMatchInlineSnapshot(`
+    [
+      "0x3603d758eb4f647bea6caa36333c816d7b46fdcb05f9466ecacc140ea8c66faf15b3d9f1",
+    ]
+  `)
+})
+it('adds contentHash call when contentHash is defined', () => {
+  expect(
+    generateRecordCallArray({
+      namehash: namehash('test.eth'),
+      contentHash: 'ipfs://Qma8mnp6xV3J2cRNf3mTth5C8nV11CAnceVinc3y8jSbio',
+    }),
+  ).toMatchInlineSnapshot(`
+    [
+      "0x304e6adeeb4f647bea6caa36333c816d7b46fdcb05f9466ecacc140ea8c66faf15b3d9f100000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000026e30101701220af4147b366bee9eb9a21a9c2d5ccdde35fa4b8d2e0d44854fc81aeb894e8ce280000000000000000000000000000000000000000000000000000",
+    ]
+  `)
+})
+it('adds abi call when abi is defined', () => {
+  expect(
+    generateRecordCallArray({
+      namehash: namehash('test.eth'),
+      abi: { contentType: 0, encodedData: '0x' },
+    }),
+  ).toMatchInlineSnapshot(`
+    [
+      "0x623195b0eb4f647bea6caa36333c816d7b46fdcb05f9466ecacc140ea8c66faf15b3d9f1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000000",
+    ]
+  `)
+})
+it('adds text calls when texts array is defined and not empty', () => {
+  expect(
+    generateRecordCallArray({
+      namehash: namehash('test.eth'),
+      texts: [{ key: 'email', value: 'cool' }],
+    }),
+  ).toMatchInlineSnapshot(`
+    [
+      "0x10f13a8ceb4f647bea6caa36333c816d7b46fdcb05f9466ecacc140ea8c66faf15b3d9f1000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000005656d61696c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004636f6f6c00000000000000000000000000000000000000000000000000000000",
+    ]
+  `)
+})
+it('adds coin calls when coins array is defined and not empty', () => {
+  expect(
+    generateRecordCallArray({
+      namehash: namehash('test.eth'),
+      coins: [
+        { coin: 'ETH', value: '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266' },
+      ],
+    }),
+  ).toMatchInlineSnapshot(`
+    [
+      "0x8b95dd71eb4f647bea6caa36333c816d7b46fdcb05f9466ecacc140ea8c66faf15b3d9f1000000000000000000000000000000000000000000000000000000000000003c00000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000014f39fd6e51aad88f6f4ce6ab8827279cfffb92266000000000000000000000000",
+    ]
+  `)
+})

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
+}