@ensdomains/ensjs 3.0.0-alpha.5 → 3.0.0-alpha.50

package/src/utils/fuses.ts

@@ -1,23 +1,360 @@
+// 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
+
+// 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,
+} 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 = [
+  64, 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 Error(
+      `Fuse number must be limited to uint32, ${fuses} was too ${
+        fuses < 1 ? 'low' : 'high'
+      }.`,
+    )
+  } else if (fuses % 1 !== 0) {
+    throw new Error(`Fuse number must be an integer, ${fuses} was not.`)
+  } else if ((fuses & USER_SETTABLE_FUSES) !== fuses) {
+    throw new Error(
+      `Fuse number must be limited to user settable fuses, ${fuses} 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 Error('Cannot specify an exact fuse value when restricted.')
+    }
+    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 Error("Can't specify fuse category when restricted.")
+      }
+      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 Error(
+            '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 Error(
+            "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 Error(
+            '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 Error(
+            "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 Error('Must specify at least one fuse.')
+    }
+
+    for (const fuse of namedArray) {
+      if (!allowedNamed.includes(fuse)) {
+        if (!userSettableFuseKeys.includes(fuse)) {
+          throw new Error(`${fuse} is not a valid named fuse.`)
+        }
+        throw new Error(`Fuse ${fuse} is not allowed for this operation.`)
+      }
+      encodedFuses |= userSettableFuseEnum[fuse]
+    }
+    for (const fuse of unnamedArray) {
+      if (!allowedUnnamed.includes(fuse)) {
+        if (!unnamedUserSettableFuses.includes(fuse)) {
+          throw new Error(
+            `${fuse} is not a valid unnamed fuse. If you are trying to set a named fuse, use the named property.`,
+          )
+        }
+        throw new Error(`Fuse ${fuse} is not allowed for this operation.`)
+      }
+      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/hexEncodedName.ts

@@ -2,3 +2,6 @@ import packet from 'dns-packet'
 
 export const hexEncodeName = (name: string) =>
   `0x${packet.name.encode(name).toString('hex')}`
+
+export const hexDecodeName = (hex: string): string =>
+  packet.name.decode(Buffer.from(hex.slice(2), 'hex')).toString()

package/src/utils/labels.ts

@@ -1,6 +1,8 @@
-import { solidityKeccak256 } from 'ethers/lib/utils'
+import { keccak256 as solidityKeccak256 } from '@ethersproject/solidity'
 import { truncateFormat } from './format'
 
+const hasLocalStorage = typeof localStorage !== 'undefined'
+
 export const labelhash = (input: string) =>
   solidityKeccak256(['string'], [input])
 
@@ -17,7 +19,7 @@ export function decodeLabelhash(hash: string) {
     throw Error('Expected encoded labelhash to have a length of 66')
   }
 
-  return `${hash.slice(1, -1)}`
+  return `0x${hash.slice(1, -1)}`
 }
 
 export function encodeLabelhash(hash: string) {
@@ -37,13 +39,13 @@ export function isEncodedLabelhash(hash: string) {
 }
 
 function getLabels() {
-  return localStorage
+  return hasLocalStorage
     ? JSON.parse(localStorage.getItem('ensjs:labels') as string) || {}
     : {}
 }
 
 function _saveLabel(hash: string, label: any) {
-  if (!localStorage) return hash
+  if (!hasLocalStorage) return hash
   const labels = getLabels()
   localStorage.setItem(
     'ensjs:labels',
@@ -62,21 +64,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
   }
+  return hash
 }
 
 export function encodeLabel(label: any) {
@@ -99,14 +99,14 @@ 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 (!localStorage) return 'Empty (0 KB)'
+  if (!hasLocalStorage) return 'Empty (0 KB)'
   let allStrings = ''
   for (const key in window.localStorage) {
     if (Object.prototype.hasOwnProperty.call(window.localStorage, key)) {
@@ -117,3 +117,7 @@ export function checkLocalStorageSize() {
     ? `${3 + (allStrings.length * 16) / (8 * 1024)} KB`
     : 'Empty (0 KB)'
 }
+
+const encodedLabelRegex = /\[[a-fA-F0-9]{64}\]/g
+export const getEncryptedLabelAmount = (name: string) =>
+  name.match(encodedLabelRegex)?.length || 0

package/src/utils/normalise.ts

@@ -1,5 +1,8 @@
-import { concat, hexlify, keccak256, toUtf8Bytes } from 'ethers/lib/utils'
+import { concat, hexlify } from '@ethersproject/bytes'
+import { keccak256 } from '@ethersproject/keccak256'
+import { toUtf8Bytes } from '@ethersproject/strings'
 import uts46 from 'idna-uts46-hx/uts46bundle.js'
+import { decodeLabelhash, isEncodedLabelhash } from './labels'
 
 const zeros = new Uint8Array(32)
 zeros.fill(0)
@@ -7,16 +10,21 @@ zeros.fill(0)
 export const normalise = (name: string) =>
   name ? uts46.toUnicode(name, { useStd3ASCII: true }) : name
 
-export const namehash = (inputName: string): string => {
+export const namehash = (name: string): string => {
   let result: string | Uint8Array = zeros
 
-  const name = normalise(inputName)
-
   if (name) {
     const labels = name.split('.')
 
-    for (var i = labels.length - 1; i >= 0; i--) {
-      const labelSha = keccak256(toUtf8Bytes(labels[i]))
+    for (let i = labels.length - 1; i >= 0; i -= 1) {
+      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]))
     }
   } else {

package/src/utils/recordHelpers.ts

@@ -1,4 +1,7 @@
 import { formatsByCoinType, formatsByName } from '@ensdomains/address-encoder'
+import { isBytesLike } from '@ethersproject/bytes'
+import { toUtf8Bytes } from '@ethersproject/strings'
+import type { BigNumberish } from 'ethers'
 import type { PublicResolver } from '../generated'
 import { encodeContenthash } from './contentHash'
 
@@ -7,10 +10,19 @@ type RecordItem = {
   value: string
 }
 
+type ABIEncodeAs = 'json' | 'zlib' | 'cbor' | 'uri'
+
+type ABIItem = {
+  contentType?: BigNumberish
+  data: object | string
+}
+
 export type RecordOptions = {
+  clearRecords?: boolean
   contentHash?: string
   texts?: RecordItem[]
   coinTypes?: RecordItem[]
+  abi?: ABIItem
 }
 
 export const generateSetAddr = (
@@ -20,7 +32,7 @@ export const generateSetAddr = (
   resolver: PublicResolver,
 ) => {
   let coinTypeInstance
-  if (!isNaN(parseInt(coinType))) {
+  if (!Number.isNaN(parseInt(coinType))) {
     coinTypeInstance = formatsByCoinType[parseInt(coinType)]
   } else {
     coinTypeInstance = formatsByName[coinType.toUpperCase()]
@@ -33,6 +45,97 @@ export const generateSetAddr = (
   )
 }
 
+export const generateABIInput = async (
+  encodeAs: ABIEncodeAs,
+  data: object | string,
+) => {
+  let contentType: number
+  let encodedData: string | Buffer | Uint8Array
+  switch (encodeAs) {
+    case 'json':
+      contentType = 1
+      encodedData = JSON.stringify(data)
+      break
+    case 'zlib': {
+      contentType = 2
+      const { deflate } = await import('pako/dist/pako_deflate.min.js')
+      encodedData = deflate(JSON.stringify(data))
+      break
+    }
+    case 'cbor': {
+      contentType = 4
+      const { encode } = await import('cbor')
+      encodedData = encode(data)
+      break
+    }
+    default: {
+      contentType = 8
+      encodedData = data as string
+      break
+    }
+  }
+  return { contentType, data: encodedData }
+}
+
+export type RecordTypes = 'contentHash' | 'text' | 'addr' | 'abi'
+
+export type RecordInput<T extends RecordTypes> = T extends 'contentHash'
+  ? string
+  : T extends 'abi'
+  ? ABIItem
+  : RecordItem
+
+export function generateSingleRecordCall<T extends RecordTypes>(
+  namehash: string,
+  resolver: PublicResolver,
+  type: T,
+): (record: RecordInput<T>) => string {
+  if (type === 'contentHash') {
+    return (_r: RecordInput<T>) => {
+      const record = _r as string
+      let _contentHash = ''
+      if (record !== _contentHash) {
+        const encoded = encodeContenthash(record)
+        if (encoded.error) throw new Error(encoded.error)
+        _contentHash = encoded.encoded as string
+      }
+      return resolver.interface.encodeFunctionData('setContenthash', [
+        namehash,
+        _contentHash,
+      ])
+    }
+  }
+  if (type === 'abi') {
+    return (_r: RecordInput<T>) => {
+      const record = _r as ABIItem
+      const { contentType = 1, data } = record
+      let encodedData = data as string | Uint8Array | Buffer
+      if (!isBytesLike(encodedData)) {
+        if (typeof encodedData === 'object') {
+          encodedData = JSON.stringify(encodedData)
+        }
+        encodedData = toUtf8Bytes(encodedData)
+      }
+      return resolver.interface.encodeFunctionData('setABI', [
+        namehash,
+        contentType,
+        encodedData,
+      ])
+    }
+  }
+  return (_r: RecordInput<T>) => {
+    const record = _r as RecordItem
+    if (type === 'text') {
+      return resolver.interface.encodeFunctionData('setText', [
+        namehash,
+        record.key,
+        record.value,
+      ])
+    }
+    return generateSetAddr(namehash, record.key, record.value, resolver)
+  }
+}
+
 export const generateRecordCallArray = (
   namehash: string,
   records: RecordOptions,
@@ -40,32 +143,40 @@ export const generateRecordCallArray = (
 ) => {
   const calls: string[] = []
 
-  if (records.contentHash) {
-    const contentHash =
-      records.contentHash === '' ? '' : encodeContenthash(records.contentHash)
-    const data = (resolver?.interface.encodeFunctionData as any)(
-      'setContenthash',
-      [namehash, contentHash],
+  if (records.clearRecords) {
+    calls.push(
+      resolver.interface.encodeFunctionData('clearRecords', [namehash]),
     )
-    data && calls.push(data)
+  }
+
+  if (records.contentHash) {
+    const data = generateSingleRecordCall(
+      namehash,
+      resolver,
+      'contentHash',
+    )(records.contentHash)
+    if (data) calls.push(data)
+  }
+
+  if (records.abi) {
+    const data = generateSingleRecordCall(
+      namehash,
+      resolver,
+      'abi',
+    )(records.abi)
+    if (data) calls.push(data)
   }
 
   if (records.texts && records.texts.length > 0) {
-    records.texts.forEach(({ key, value }: RecordItem) => {
-      const data = resolver?.interface.encodeFunctionData('setText', [
-        namehash,
-        key,
-        value,
-      ])
-      data && calls.push(data)
-    })
+    records.texts
+      .map(generateSingleRecordCall(namehash, resolver, 'text'))
+      .forEach((call) => calls.push(call))
   }
 
   if (records.coinTypes && records.coinTypes.length > 0) {
-    records.coinTypes.forEach(({ key, value }: RecordItem) => {
-      const data = generateSetAddr(namehash, key, value, resolver!)
-      data && calls.push(data)
-    })
+    records.coinTypes
+      .map(generateSingleRecordCall(namehash, resolver, 'addr'))
+      .forEach((call) => calls.push(call))
   }
 
   return calls