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

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(/\.$/, '')
+}

package/src/utils/index.ts

@@ -0,0 +1,103 @@
+export {
+  encodeAbi,
+  type EncodeAbiParameters,
+  type EncodeAbiReturnType,
+  type EncodedAbi,
+} from './encoders/encodeAbi.js'
+export {
+  encodeSetAbi,
+  type EncodeSetAbiParameters,
+  type EncodeSetAbiReturnType,
+} from './encoders/encodeSetAbi.js'
+export {
+  encodeSetAddr,
+  type EncodeSetAddrParameters,
+  type EncodeSetAddrReturnType,
+} from './encoders/encodeSetAddr.js'
+export {
+  encodeSetContentHash,
+  type EncodeSetContentHashParameters,
+  type EncodeSetContentHashReturnType,
+} from './encoders/encodeSetContentHash.js'
+export {
+  encodeSetText,
+  type EncodeSetTextParameters,
+  type EncodeSetTextReturnType,
+} from './encoders/encodeSetText.js'
+
+export {
+  EMPTY_ADDRESS,
+  GRACE_PERIOD_SECONDS,
+  MAX_DATE_INT,
+  MAX_INT_64,
+  MINIMUM_DOT_ETH_CHARS,
+} from './consts.js'
+
+export {
+  decodeContenthash,
+  encodeContenthash,
+  getProtocolType,
+  isValidContenthash,
+  validateContent,
+  type DecodedContentHash,
+  type ProtocolType,
+} from './contentHash.js'
+export { bracketFormat, formatHashed, truncateFormat } from './format.js'
+export {
+  generateRecordCallArray,
+  type RecordOptions,
+} from './generateRecordCallArray.js'
+export { bytesToPacket, packetToBytes } from './hexEncodedName.js'
+export {
+  checkIsDecrypted,
+  checkLabel,
+  decodeLabelhash,
+  decryptName,
+  encodeLabelhash,
+  isEncodedLabelhash,
+  saveLabel,
+  saveName,
+} from './labels.js'
+export { makeSafeSecondsDate } from './makeSafeSecondsDate.js'
+export {
+  beautify,
+  emoji,
+  isCombiningMark,
+  namehash,
+  normalise,
+  normaliseFragment,
+  shouldEscape,
+  split,
+  tokenise,
+  type DisallowedToken,
+  type EmojiToken,
+  type IgnoredToken,
+  type Label,
+  type MappedToken,
+  type NFCToken,
+  type StopToken,
+  type TextToken,
+  type Token,
+  type ValidToken,
+} from './normalise.js'
+export {
+  makeCommitment,
+  makeCommitmentFromTuple,
+  makeCommitmentTuple,
+  makeRegistrationTuple,
+  randomSecret,
+  type CommitmentTuple,
+  type RegistrationParameters,
+  type RegistrationTuple,
+} from './registerHelpers.js'
+export {
+  checkIsDotEth,
+  parseInput,
+  validateName,
+  type ParsedInputResult,
+} from './validation.js'
+export {
+  MAX_EXPIRY,
+  expiryToBigInt,
+  wrappedLabelLengthCheck,
+} from './wrapper.js'

package/src/utils/labels.test.ts

@@ -0,0 +1,163 @@
+import { labelhash } from 'viem'
+import { getVersion } from '../errors/error-utils.js'
+import {
+  decodeLabelhash,
+  encodeLabelhash,
+  isEncodedLabelhash,
+  saveLabel,
+  saveName,
+} from './labels.js'
+
+describe('decodeLabelhash()', () => {
+  it('decodes labelhash', () => {
+    expect(
+      decodeLabelhash(
+        '[9c22ff5f21f0b81b113e63f7db6da94fedef11b2119b4088b89664fb9a3cb658]',
+      ),
+    ).toEqual(
+      '0x9c22ff5f21f0b81b113e63f7db6da94fedef11b2119b4088b89664fb9a3cb658',
+    )
+  })
+  it('throws error when label does not start with [', () => {
+    expect(() =>
+      decodeLabelhash(
+        '9c22ff5f21f0b81b113e63f7db6da94fedef11b2119b4088b89664fb9a3cb658]',
+      ),
+    ).toThrowErrorMatchingInlineSnapshot(`
+      "Invalid encoded label
+
+      - Supplied label: 9c22ff5f21f0b81b113e63f7db6da94fedef11b2119b4088b89664fb9a3cb658]
+
+      Details: Expected encoded labelhash to start and end with square brackets
+
+      Version: ${getVersion()}"
+    `)
+  })
+  it('throws error when label does not end with ]', () => {
+    expect(() =>
+      decodeLabelhash(
+        '[9c22ff5f21f0b81b113e63f7db6da94fedef11b2119b4088b89664fb9a3cb658',
+      ),
+    ).toThrowErrorMatchingInlineSnapshot(`
+      "Invalid encoded label
+
+      - Supplied label: [9c22ff5f21f0b81b113e63f7db6da94fedef11b2119b4088b89664fb9a3cb658
+
+      Details: Expected encoded labelhash to start and end with square brackets
+
+      Version: ${getVersion()}"
+    `)
+  })
+  it('throws error when label length is not 66', () => {
+    expect(() =>
+      decodeLabelhash(
+        '[9c22ff5f21f0b81b113e63f7db6da94fedef11b2119b4088b89664fb9a3cb65]',
+      ),
+    ).toThrowErrorMatchingInlineSnapshot(`
+      "Invalid encoded label
+
+      - Supplied label: [9c22ff5f21f0b81b113e63f7db6da94fedef11b2119b4088b89664fb9a3cb65]
+
+      Details: Expected encoded labelhash to have a length of 66
+
+      Version: ${getVersion()}"
+    `)
+  })
+})
+
+describe('encodeLabelhash()', () => {
+  it('encodes labelhash', () => {
+    expect(
+      encodeLabelhash(
+        '0x9c22ff5f21f0b81b113e63f7db6da94fedef11b2119b4088b89664fb9a3cb658',
+      ),
+    ).toEqual(
+      '[9c22ff5f21f0b81b113e63f7db6da94fedef11b2119b4088b89664fb9a3cb658]',
+    )
+  })
+  it('throws error when labelhash does not start with 0x', () => {
+    expect(() =>
+      encodeLabelhash(
+        '9c22ff5f21f0b81b113e63f7db6da94fedef11b2119b4088b89664fb9a3cb658',
+      ),
+    ).toThrowErrorMatchingInlineSnapshot(`
+      "Invalid labelhash
+
+      - Supplied labelhash: 9c22ff5f21f0b81b113e63f7db6da94fedef11b2119b4088b89664fb9a3cb658
+
+      Details: Expected labelhash to start with 0x
+
+      Version: ${getVersion()}"
+    `)
+  })
+  it('throws error when labelhash length is not 66', () => {
+    expect(() =>
+      encodeLabelhash(
+        '0x9c22ff5f21f0b81b113e63f7db6da94fedef11b2119b4088b89664fb9a3cb65',
+      ),
+    ).toThrowErrorMatchingInlineSnapshot(`
+      "Invalid labelhash
+
+      - Supplied labelhash: 0x9c22ff5f21f0b81b113e63f7db6da94fedef11b2119b4088b89664fb9a3cb65
+
+      Details: Expected labelhash to have a length of 66
+
+      Version: ${getVersion()}"
+    `)
+  })
+})
+
+describe('isEncodedLabelhash()', () => {
+  it('returns true when labelhash is encoded', () => {
+    expect(
+      isEncodedLabelhash(
+        '[9c22ff5f21f0b81b113e63f7db6da94fedef11b2119b4088b89664fb9a3cb658]',
+      ),
+    ).toBe(true)
+  })
+  it('returns false when labelhash is not encoded', () => {
+    expect(isEncodedLabelhash('sdfsdfsd')).toBe(false)
+  })
+})
+
+describe('saveLabel()', () => {
+  it('saves label to localStorage', () => {
+    jest.spyOn(global.localStorage, 'setItem')
+    saveLabel('test')
+    expect(global.localStorage.setItem).toHaveBeenCalledWith(
+      'ensjs:labels',
+      JSON.stringify({ [labelhash('test')]: 'test' }),
+    )
+  })
+})
+
+describe('saveName()', () => {
+  beforeEach(() => {
+    global.localStorage.clear()
+  })
+  it('saves each label from name to localStorage', () => {
+    jest.spyOn(global.localStorage, 'setItem')
+    saveName('test.eth')
+    expect(global.localStorage.setItem).toHaveBeenCalledWith(
+      'ensjs:labels',
+      JSON.stringify({ [labelhash('test')]: 'test' }),
+    )
+    expect(global.localStorage.setItem).toHaveBeenCalledWith(
+      'ensjs:labels',
+      JSON.stringify({
+        [labelhash('test')]: 'test',
+        [labelhash('eth')]: 'eth',
+      }),
+    )
+  })
+  it('does not save encoded label to localStorage', () => {
+    jest.spyOn(global.localStorage, 'setItem')
+    saveName(
+      '[9c22ff5f21f0b81b113e63f7db6da94fedef11b2119b4088b89664fb9a3cb658].eth',
+    )
+    expect(global.localStorage.setItem).toHaveBeenCalledWith(
+      'ensjs:labels',
+      JSON.stringify({ [labelhash('eth')]: 'eth' }),
+    )
+  })
+})

package/src/utils/labels.ts

@@ -1,35 +1,40 @@
-import { solidityKeccak256 } from 'ethers/lib/utils'
-import { truncateFormat } from './format'
+import { labelhash, type Hex } from 'viem'
+import {
+  InvalidEncodedLabelError,
+  InvalidLabelhashError,
+} from '../errors/utils.js'
 
 const hasLocalStorage = typeof localStorage !== 'undefined'
 
-export const labelhash = (input: string) =>
-  solidityKeccak256(['string'], [input])
-
-export const keccakFromString = (input: string) => labelhash(input)
-
-export function decodeLabelhash(hash: string) {
-  if (!(hash.startsWith('[') && hash.endsWith(']'))) {
-    throw Error(
-      'Expected encoded labelhash to start and end with square brackets',
-    )
-  }
-
-  if (hash.length !== 66) {
-    throw Error('Expected encoded labelhash to have a length of 66')
-  }
-
-  return `${hash.slice(1, -1)}`
+export function decodeLabelhash(hash: string): Hex {
+  if (!(hash.startsWith('[') && hash.endsWith(']')))
+    throw new InvalidEncodedLabelError({
+      label: hash,
+      details:
+        'Expected encoded labelhash to start and end with square brackets',
+    })
+
+  if (hash.length !== 66)
+    throw new InvalidEncodedLabelError({
+      label: hash,
+      details: 'Expected encoded labelhash to have a length of 66',
+    })
+
+  return `0x${hash.slice(1, -1)}`
 }
 
 export function encodeLabelhash(hash: string) {
-  if (!hash.startsWith('0x')) {
-    throw new Error('Expected label hash to start with 0x')
-  }
-
-  if (hash.length !== 66) {
-    throw new Error('Expected label hash to have a length of 66')
-  }
+  if (!hash.startsWith('0x'))
+    throw new InvalidLabelhashError({
+      labelhash: hash,
+      details: 'Expected labelhash to start with 0x',
+    })
+
+  if (hash.length !== 66)
+    throw new InvalidLabelhashError({
+      labelhash: hash,
+      details: 'Expected labelhash to have a length of 66',
+    })
 
   return `[${hash.slice(2)}]`
 }
@@ -64,34 +69,19 @@ export function saveLabel(label: string) {
 
 export function saveName(name: string) {
   const nameArray = name.split('.')
-  nameArray.forEach((label: any) => {
-    saveLabel(label)
-  })
+  for (const label of nameArray) {
+    if (!isEncodedLabelhash(label)) {
+      saveLabel(label)
+    }
+  }
 }
 
-// eslint-disable-next-line consistent-return
-export function checkLabel(hash: string): string | undefined {
+export function checkLabel(hash: string): string {
   const labels = getLabels()
   if (isEncodedLabelhash(hash)) {
-    return labels[decodeLabelhash(hash)]
-  }
-
-  if (hash.startsWith('0x')) {
-    return labels[`${hash.slice(2)}`]
+    return labels[decodeLabelhash(hash)] || hash
   }
-}
-
-export function encodeLabel(label: any) {
-  try {
-    return encodeLabelhash(label)
-  } catch {
-    return label
-  }
-}
-
-export function parseName(name: string) {
-  const nameArray = name.split('.')
-  return nameArray.map((label: any) => encodeLabel(label)).join('.')
+  return hash
 }
 
 export function checkIsDecrypted(string: string | string[]) {
@@ -101,21 +91,6 @@ export function checkIsDecrypted(string: string | string[]) {
 export function decryptName(name: string) {
   return name
     .split('.')
-    .map((label: any) => checkLabel(label) || label)
+    .map((label: any) => checkLabel(label))
     .join('.')
 }
-
-export const truncateUndecryptedName = (name: string) => truncateFormat(name)
-
-export function checkLocalStorageSize() {
-  if (!hasLocalStorage) return 'Empty (0 KB)'
-  let allStrings = ''
-  for (const key in window.localStorage) {
-    if (Object.prototype.hasOwnProperty.call(window.localStorage, key)) {
-      allStrings += window.localStorage[key]
-    }
-  }
-  return allStrings
-    ? `${3 + (allStrings.length * 16) / (8 * 1024)} KB`
-    : 'Empty (0 KB)'
-}

package/src/utils/makeLabelNodeAndParent.test.ts

@@ -0,0 +1,11 @@
+import { makeLabelNodeAndParent } from './makeLabelNodeAndParent.js'
+
+it('makes label node and parent', () => {
+  expect(makeLabelNodeAndParent('test.eth')).toMatchInlineSnapshot(`
+    {
+      "label": "test",
+      "labelhash": "0x9c22ff5f21f0b81b113e63f7db6da94fedef11b2119b4088b89664fb9a3cb658",
+      "parentNode": "0x93cdeb708b7545dc668eb9280176169d1c33cfd8ed6f04690a0bcc88a93fc4ae",
+    }
+  `)
+})

package/src/utils/makeLabelNodeAndParent.ts

@@ -0,0 +1,13 @@
+import { labelhash } from 'viem'
+import { namehash } from './normalise.js'
+
+export const makeLabelNodeAndParent = (name: string) => {
+  const labels = name.split('.')
+  const label = labels.shift() as string
+  const parentNode = namehash(labels.join('.'))
+  return {
+    label,
+    labelhash: labelhash(label),
+    parentNode,
+  }
+}

package/src/utils/makeSafeSecondsDate.test.ts

@@ -0,0 +1,14 @@
+import { MAX_DATE_INT } from './consts.js'
+import { makeSafeSecondsDate } from './makeSafeSecondsDate.js'
+
+it('makes date from seconds', () => {
+  expect(makeSafeSecondsDate(21000)).toEqual(new Date(21000000))
+})
+it('makes date from seconds with big int', () => {
+  expect(makeSafeSecondsDate(21000n)).toEqual(new Date(21000000))
+})
+it('makes date from seconds with big int larger than max date int', () => {
+  expect(makeSafeSecondsDate(MAX_DATE_INT + 28930402)).toEqual(
+    new Date(MAX_DATE_INT),
+  )
+})

package/src/utils/makeSafeSecondsDate.ts

@@ -0,0 +1,7 @@
+import { MAX_DATE_INT } from './consts.js'
+
+export const makeSafeSecondsDate = (seconds: number | bigint) => {
+  const milliseconds = BigInt(seconds) * 1000n
+  if (milliseconds > BigInt(MAX_DATE_INT)) return new Date(MAX_DATE_INT)
+  return new Date(Number(milliseconds))
+}

package/src/utils/normalise.test.ts

@@ -0,0 +1,35 @@
+import { namehash } from './normalise.js'
+
+describe('namehash()', () => {
+  it('returns namehash for name', () => {
+    expect(namehash('test.eth')).toEqual(
+      '0xeb4f647bea6caa36333c816d7b46fdcb05f9466ecacc140ea8c66faf15b3d9f1',
+    )
+  })
+  it('returns namehash for name with encoded labelhash', () => {
+    expect(
+      namehash(
+        '[9c22ff5f21f0b81b113e63f7db6da94fedef11b2119b4088b89664fb9a3cb658].eth',
+      ),
+    ).toEqual(
+      '0xeb4f647bea6caa36333c816d7b46fdcb05f9466ecacc140ea8c66faf15b3d9f1',
+    )
+  })
+})
+
+it('exports functions from ens-normalize', async () => {
+  const modules = await import('./normalise.js')
+  expect(modules).toMatchInlineSnapshot(`
+    {
+      "beautify": [Function],
+      "emoji": [Function],
+      "isCombiningMark": [Function],
+      "namehash": [Function],
+      "normalise": [Function],
+      "normaliseFragment": [Function],
+      "shouldEscape": [Function],
+      "split": [Function],
+      "tokenise": [Function],
+    }
+  `)
+})

package/src/utils/normalise.ts

@@ -1,33 +1,68 @@
-import { concat, hexlify, keccak256, toUtf8Bytes } from 'ethers/lib/utils'
-import uts46 from 'idna-uts46-hx/uts46bundle.js'
-import { decodeLabelhash, isEncodedLabelhash } from './labels'
+import {
+  ens_beautify,
+  ens_emoji,
+  ens_normalize,
+  ens_normalize_fragment,
+  ens_split,
+  ens_tokenize,
+  is_combining_mark,
+  should_escape,
+  type DisallowedToken,
+  type EmojiToken,
+  type IgnoredToken,
+  type Label,
+  type MappedToken,
+  type NFCToken,
+  type StopToken,
+  type TextToken,
+  type Token,
+  type ValidToken,
+} from '@adraffy/ens-normalize'
+import { bytesToHex, concat, hexToBytes, keccak256, stringToBytes } from 'viem'
+import { decodeLabelhash, isEncodedLabelhash } from './labels.js'
 
 const zeros = new Uint8Array(32)
 zeros.fill(0)
 
-export const normalise = (name: string) =>
-  name ? uts46.toUnicode(name, { useStd3ASCII: true }) : name
+export const normalise = (name: string) => (name ? ens_normalize(name) : name)
 
-export const namehash = (name: string): string => {
-  let result: string | Uint8Array = zeros
+export function namehash(name: string) {
+  let result = new Uint8Array(32).fill(0)
+  if (!name) return bytesToHex(result)
 
-  if (name) {
-    const labels = name.split('.')
-
-    for (var i = labels.length - 1; i >= 0; i--) {
-      let labelSha: string
-      if (isEncodedLabelhash(labels[i])) {
-        labelSha = decodeLabelhash(labels[i])
-      } else {
-        const normalised = normalise(labels[i])
-        labelSha = keccak256(toUtf8Bytes(normalised))
-      }
-
-      result = keccak256(concat([result, labelSha]))
+  const labels = name.split('.')
+  // Iterate in reverse order building up hash
+  for (let i = labels.length - 1; i >= 0; i -= 1) {
+    let labelSha: Uint8Array
+    if (isEncodedLabelhash(labels[i])) {
+      labelSha = hexToBytes(decodeLabelhash(labels[i]))
+    } else {
+      const normalised = normalise(labels[i])
+      labelSha = keccak256(stringToBytes(normalised), 'bytes')
     }
-  } else {
-    result = hexlify(zeros)
+    result = keccak256(concat([result, labelSha]), 'bytes')
   }
 
-  return result as string
+  return bytesToHex(result)
+}
+
+export const beautify = ens_beautify
+export const emoji = ens_emoji
+export const normaliseFragment = ens_normalize_fragment
+export const split = ens_split
+export const tokenise = ens_tokenize
+export const isCombiningMark = is_combining_mark
+export const shouldEscape = should_escape
+
+export type {
+  DisallowedToken,
+  EmojiToken,
+  IgnoredToken,
+  Label,
+  MappedToken,
+  NFCToken,
+  StopToken,
+  TextToken,
+  Token,
+  ValidToken,
 }

package/src/utils/ownerFromContract.test.ts

@@ -0,0 +1,52 @@
+import { getVersion } from '../errors/error-utils.js'
+import { deploymentAddresses, publicClient } from '../tests/addTestContracts.js'
+import { namehash } from './normalise.js'
+import { ownerFromContract } from './ownerFromContract.js'
+
+const baseParams = {
+  client: publicClient,
+  namehash: namehash('test.eth'),
+}
+
+it('uses nameWrapper contract when contract is nameWrapper', () => {
+  expect(ownerFromContract({ ...baseParams, contract: 'nameWrapper' }))
+    .toMatchInlineSnapshot(`
+    {
+      "data": "0x6352211eeb4f647bea6caa36333c816d7b46fdcb05f9466ecacc140ea8c66faf15b3d9f1",
+      "to": "${deploymentAddresses.NameWrapper}",
+    }
+  `)
+})
+it('uses registry contract when contract is registry', () => {
+  expect(ownerFromContract({ ...baseParams, contract: 'registry' }))
+    .toMatchInlineSnapshot(`
+    {
+      "data": "0x02571be3eb4f647bea6caa36333c816d7b46fdcb05f9466ecacc140ea8c66faf15b3d9f1",
+      "to": "${deploymentAddresses.ENSRegistry}",
+    }
+  `)
+})
+it('uses registrar contract when contract is registrar', () => {
+  expect(
+    ownerFromContract({
+      ...baseParams,
+      contract: 'registrar',
+      labels: ['test'],
+    }),
+  ).toMatchInlineSnapshot(`
+    {
+      "data": "0x6352211e9c22ff5f21f0b81b113e63f7db6da94fedef11b2119b4088b89664fb9a3cb658",
+      "to": "${deploymentAddresses.BaseRegistrarImplementation}",
+    }
+  `)
+})
+it('throws when contract is not nameWrapper, registry, or registrar', () => {
+  expect(() => ownerFromContract({ ...baseParams, contract: 'invalid' as any }))
+    .toThrowErrorMatchingInlineSnapshot(`
+    "Invalid contract type: invalid
+
+    - Supported contract types: nameWrapper, registry, registrar
+
+    Version: ${getVersion()}"
+  `)
+})