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

package/src/utils/index.ts

@@ -0,0 +1,135 @@
+export {
+  contentTypeToEncodeAs,
+  encodeAbi,
+  encodeAsToContentType,
+  type EncodeAbiParameters,
+  type EncodeAbiReturnType,
+  type EncodedAbi,
+} from './encoders/encodeAbi.js'
+export { encodeClearRecords } from './encoders/encodeClearRecords.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 {
+  ChildFuseKeys,
+  ChildFuseReference,
+  ChildFuses,
+  FullParentFuseKeys,
+  FullParentFuseReference,
+  FullParentFuses,
+  FuseRanges,
+  ParentFuseKeys,
+  ParentFuseReference,
+  ParentFuses,
+  UnnamedChildFuseKeys,
+  UnnamedChildFuses,
+  UnnamedParentFuseKeys,
+  UnnamedParentFuses,
+  UserSettableFuseKeys,
+  UserSettableFuses,
+  checkPccBurned,
+  decodeFuses,
+  encodeFuses,
+  type ChildFuseReferenceType,
+  type DecodedFuses,
+  type EncodeChildFusesInputObject,
+  type EncodeFusesInputObject,
+  type EncodeParentFusesInputObject,
+  type FullParentFuseReferenceType,
+  type ParentFuseReferenceType,
+} from './fuses.js'
+
+export {
+  decodeContentHash,
+  encodeContentHash,
+  getDisplayCodec,
+  getInternalCodec,
+  getProtocolType,
+  isValidContentHash,
+  type DecodedContentHash,
+  type ProtocolType,
+} from './contentHash.js'
+export { 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.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.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.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.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/normaliseCoinId.ts

@@ -0,0 +1,36 @@
+import {
+  getCoderByCoinName,
+  getCoderByCoinType,
+  type Coin,
+} from '@ensdomains/address-encoder'
+import { CoinFormatterNotFoundError } from '../errors/public.js'
+
+export const normaliseCoinId = (coinId: string | number) => {
+  const isString = typeof coinId === 'string'
+
+  if (isString && Number.isNaN(parseInt(coinId))) {
+    return {
+      type: 'name',
+      value: coinId.toLowerCase().replace(/legacy$/, 'Legacy'),
+    } as const
+  }
+  return {
+    type: 'id',
+    value: isString ? parseInt(coinId as string) : (coinId as number),
+  } as const
+}
+
+export const getCoderFromCoin = (coinId: string | number): Coin => {
+  const normalisedCoin = normaliseCoinId(coinId)
+  let coder: Coin
+  try {
+    coder =
+      normalisedCoin.type === 'id'
+        ? getCoderByCoinType(normalisedCoin.value)
+        : getCoderByCoinName(normalisedCoin.value)
+  } catch {
+    throw new CoinFormatterNotFoundError({ coinType: coinId })
+  }
+
+  return coder
+}

package/src/utils/ownerFromContract.ts

@@ -0,0 +1,70 @@
+import { encodeFunctionData, labelhash, type Hex } from 'viem'
+import { baseRegistrarOwnerOfSnippet } from '../contracts/baseRegistrar.js'
+import type { ClientWithEns } from '../contracts/consts.js'
+import { getChainContractAddress } from '../contracts/getChainContractAddress.js'
+import { nameWrapperOwnerOfSnippet } from '../contracts/nameWrapper.js'
+import { registryOwnerSnippet } from '../contracts/registry.js'
+import { InvalidContractTypeError } from '../errors/general.js'
+
+export type OwnerContract = 'nameWrapper' | 'registry' | 'registrar'
+
+export type OwnerFromContractArgs = {
+  client: ClientWithEns
+  contract: OwnerContract
+  namehash?: Hex
+  labels?: string[]
+} & (
+  | {
+      contract: Exclude<OwnerContract, 'registrar'>
+      namehash: Hex
+    }
+  | {
+      contract: 'registrar'
+      labels: string[]
+    }
+)
+
+export const ownerFromContract = ({
+  client,
+  contract,
+  namehash,
+  labels,
+}: OwnerFromContractArgs) => {
+  switch (contract) {
+    case 'nameWrapper':
+      return {
+        to: getChainContractAddress({ client, contract: 'ensNameWrapper' }),
+        data: encodeFunctionData({
+          abi: nameWrapperOwnerOfSnippet,
+          functionName: 'ownerOf',
+          args: [BigInt(namehash)],
+        }),
+      }
+    case 'registry':
+      return {
+        to: getChainContractAddress({ client, contract: 'ensRegistry' }),
+        data: encodeFunctionData({
+          abi: registryOwnerSnippet,
+          functionName: 'owner',
+          args: [namehash],
+        }),
+      }
+    case 'registrar':
+      return {
+        to: getChainContractAddress({
+          client,
+          contract: 'ensBaseRegistrarImplementation',
+        }),
+        data: encodeFunctionData({
+          abi: baseRegistrarOwnerOfSnippet,
+          functionName: 'ownerOf',
+          args: [BigInt(labelhash(labels[0]))],
+        }),
+      }
+    default:
+      throw new InvalidContractTypeError({
+        contractType: contract,
+        supportedContractTypes: ['nameWrapper', 'registry', 'registrar'],
+      })
+  }
+}