@ensdomains/ensjs 3.0.0-alpha.3 → 3.0.0-alpha.31

package/src/utils/fuses.ts

@@ -1,3 +1,5 @@
+import { BigNumber, BigNumberish } from 'ethers'
+
 const CANNOT_UNWRAP = 1
 const CANNOT_BURN_FUSES = 2
 const CANNOT_TRANSFER = 4
@@ -7,7 +9,7 @@ const CANNOT_CREATE_SUBDOMAIN = 32
 const PARENT_CANNOT_CONTROL = 64
 const CAN_DO_EVERYTHING = 0
 
-export const testable = {
+export const fuseEnum = {
   CANNOT_UNWRAP,
   CANNOT_BURN_FUSES,
   CANNOT_TRANSFER,
@@ -15,9 +17,144 @@ export const testable = {
   CANNOT_SET_TTL,
   CANNOT_CREATE_SUBDOMAIN,
   PARENT_CANNOT_CONTROL,
-}
+} as const
+
+export type FuseOptions = { -readonly [K in keyof typeof fuseEnum]?: boolean }
+
+export const unnamedFuses = [
+  128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768, 65536, 131072, 262144,
+  524288, 1048576, 2097152, 4194304, 8388608, 16777216, 33554432, 67108864,
+  134217728, 268435456, 536870912, 1073741824, 2147483648, 4294967296,
+] as const
 
-export default {
-  ...testable,
+const fullFuseEnum = {
+  ...fuseEnum,
   CAN_DO_EVERYTHING,
 }
+
+export type FuseObj = typeof fuseEnum
+export type CurrentFuses = { [f in keyof FuseObj]: boolean } & {
+  CAN_DO_EVERYTHING: boolean
+}
+export type UnnamedFuseType = typeof unnamedFuses
+export type Fuse = keyof FuseObj
+export type UnnamedFuseValues = UnnamedFuseType[number]
+
+// We need this type so that the following type isn't infinite. This type limits the max length of the fuse array to 7.
+export type FuseArrayPossibilities =
+  | [Fuse]
+  | [Fuse, Fuse]
+  | [Fuse, Fuse, Fuse]
+  | [Fuse, Fuse, Fuse, Fuse]
+  | [Fuse, Fuse, Fuse, Fuse, Fuse]
+  | [Fuse, Fuse, Fuse, Fuse, Fuse, Fuse]
+  | [Fuse, Fuse, Fuse, Fuse, Fuse, Fuse, Fuse]
+
+/**
+ * This type creates a type error if there are any duplicate fuses.
+ * It effectively works like a reduce function, starting with 0 included types, adding a type each time, and then checking for duplicates.
+ *
+ * @template A The array to check for duplicates.
+ * @template B The union of all checked existing types.
+ */
+// CLAUSE A: This extension unwraps the type as a fuse tuple.
+type FusesWithoutDuplicates<A, B = never> = A extends FuseArrayPossibilities
+  ? // CLAUSE A > TRUE: CLAUSE B: Pick out the first item in the current array, separating the current item from the rest.
+    A extends [infer Head, ...infer Tail]
+    ? // CLAUSE B > TRUE: CLAUSE C: Check if the current item is a duplicate based on the input union.
+      Head extends B
+      ? // CLAUSE C > TRUE: Duplicate found, return an empty array to throw a type error.
+        []
+      : // CLAUSE C > FALSE: Return a new array to continue the recursion, adds the current item type to the union.
+        [Head, ...FusesWithoutDuplicates<Tail, Head | B>]
+    : // CLAUSE B > FALSE: Return the input array as there is no more array elements to check.
+      A
+  : // CLAUSE A > FALSE: Return an empty array as it isn't a fuse tuple.
+    []
+
+export type NamedFusesToBurn = FusesWithoutDuplicates<FuseArrayPossibilities>
+
+export type FusePropsNamedArray = {
+  namedFusesToBurn: NamedFusesToBurn
+}
+
+export type FusePropsUnnamedArray = {
+  unnamedFusesToBurn: UnnamedFuseValues[]
+}
+
+export type FusePropsNumber = {
+  fuseNumberToBurn: number
+}
+
+export type FuseProps =
+  | (Partial<FusePropsNamedArray> & FusePropsUnnamedArray)
+  | (FusePropsNamedArray & Partial<FusePropsUnnamedArray>)
+  | FusePropsNumber
+
+export const validateFuses = (fuses: FuseProps) => {
+  const isNumber = 'fuseNumberToBurn' in fuses
+  const hasNamedArray = 'namedFusesToBurn' in fuses
+  const hasUnnamedArray = 'unnamedFusesToBurn' in fuses
+
+  let encodedFuses: number = 0
+
+  if (isNumber) {
+    if (fuses.fuseNumberToBurn > 2 ** 32 || fuses.fuseNumberToBurn < 1) {
+      throw new Error(
+        `Fuse number must be limited to uint32, ${
+          fuses.fuseNumberToBurn
+        } was too ${fuses.fuseNumberToBurn < 1 ? 'low' : 'high'}.`,
+      )
+    } else if (fuses.fuseNumberToBurn % 1 !== 0) {
+      throw new Error(
+        `Fuse number must be an integer, ${fuses.fuseNumberToBurn} was not.`,
+      )
+    }
+    encodedFuses = fuses.fuseNumberToBurn
+  } else {
+    if (!hasNamedArray && !hasUnnamedArray) {
+      throw new Error('Please provide fuses to burn')
+    }
+    if (hasNamedArray) {
+      for (const fuse of fuses.namedFusesToBurn!) {
+        if (!(fuse in fuseEnum)) {
+          throw new Error(`${fuse} is not a valid named fuse.`)
+        }
+        encodedFuses |= fuseEnum[fuse]
+      }
+    }
+    if (hasUnnamedArray) {
+      for (const fuse of fuses.unnamedFusesToBurn!) {
+        if (!unnamedFuses.includes(fuse)) {
+          throw new Error(
+            `${fuse} is not a valid unnamed fuse. If you are trying to burn a named fuse, use the namedFusesToBurn property.`,
+          )
+        }
+        encodedFuses |= fuse
+      }
+    }
+  }
+
+  return encodedFuses
+}
+
+export const decodeFuses = (fuses: BigNumberish) => {
+  const bnFuses = BigNumber.from(fuses)
+
+  const fuseObj = Object.fromEntries(
+    Object.keys(fuseEnum).map((fuse) => [
+      fuse,
+      bnFuses.and(fuseEnum[fuse as keyof typeof fuseEnum]).gt(0),
+    ]),
+  )
+
+  if (bnFuses.eq(0)) {
+    fuseObj.CAN_DO_EVERYTHING = true
+  } else {
+    fuseObj.CAN_DO_EVERYTHING = false
+  }
+
+  return fuseObj as CurrentFuses
+}
+
+export default fullFuseEnum

package/src/utils/generateFuseInput.ts

@@ -1,16 +1,11 @@
 import { ethers } from 'ethers'
-import { FuseOptions } from '../@types/FuseOptions'
-import fuses from './fuses'
+import fuses, { FuseOptions } from './fuses'
 
 export default (fuseOptions: FuseOptions) => {
-  const fuseKeys = Object.keys(fuseOptions)
-    .filter((opt) => fuseOptions[opt as keyof FuseOptions] === true)
-    .map((opt) =>
-      opt
-        .split(/(?=[A-Z])/)
-        .join('_')
-        .toUpperCase(),
-    )
+  const fuseKeys = Object.keys(fuseOptions).filter(
+    (opt) => fuseOptions[opt as keyof FuseOptions] === true,
+  )
+
   const bigNumberFuses = fuseKeys.reduce((prev, curr) => {
     return prev.or(fuses[curr as keyof typeof fuses])
   }, ethers.BigNumber.from(0))

package/src/utils/labels.ts

@@ -1,6 +1,8 @@
 import { solidityKeccak256 } from 'ethers/lib/utils'
 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',
@@ -106,7 +108,7 @@ export function decryptName(name: string) {
 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)) {

package/src/utils/normalise.ts

@@ -1,5 +1,6 @@
 import { concat, hexlify, keccak256, toUtf8Bytes } from 'ethers/lib/utils'
 import uts46 from 'idna-uts46-hx/uts46bundle.js'
+import { decodeLabelhash, isEncodedLabelhash } from './labels'
 
 const zeros = new Uint8Array(32)
 zeros.fill(0)
@@ -7,16 +8,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

@@ -8,6 +8,7 @@ type RecordItem = {
 }
 
 export type RecordOptions = {
+  clearRecords?: boolean
   contentHash?: string
   texts?: RecordItem[]
   coinTypes?: RecordItem[]
@@ -20,7 +21,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 +34,45 @@ export const generateSetAddr = (
   )
 }
 
+export type RecordTypes = 'contentHash' | 'text' | 'addr'
+
+export type RecordInput<T extends RecordTypes> = T extends 'contentHash'
+  ? string
+  : 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,
+      ])
+    }
+  }
+  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 +80,31 @@ 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.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

package/src/utils/registerHelpers.ts

@@ -1,17 +1,70 @@
-import { utils } from 'ethers'
-import type { FuseOptions } from '../@types/FuseOptions'
+import { BigNumberish, utils } from 'ethers'
 import type { PublicResolver } from '../generated'
+import { FuseOptions } from './fuses'
 import generateFuseInput from './generateFuseInput'
 import { labelhash } from './labels'
 import { namehash } from './normalise'
 import { generateRecordCallArray, RecordOptions } from './recordHelpers'
 
+export const MAX_INT_64 = 2n ** 64n - 1n
+
+export type BaseRegistrationParams = {
+  owner: string
+  duration: number
+  secret: string
+  resolverAddress?: string
+  records?: RecordOptions
+  reverseRecord?: boolean
+  fuses?: FuseOptions
+  wrapperExpiry?: BigNumberish
+}
+
+export type RegistrationParams = Omit<
+  BaseRegistrationParams,
+  'resolverAddress'
+> & {
+  name: string
+  resolver: PublicResolver
+}
+
+export type CommitmentParams = Omit<
+  RegistrationParams,
+  'secret' | 'wrapperExpiry'
+> & {
+  secret?: string
+  wrapperExpiry?: BigNumberish
+}
+
+export type RegistrationTuple = [
+  name: string,
+  owner: string,
+  duration: number,
+  secret: string,
+  resolver: string,
+  data: string[],
+  reverseRecord: boolean,
+  fuses: string,
+  wrapperExpiry: BigNumberish,
+]
+
+export type CommitmentTuple = [
+  labelhash: string,
+  owner: string,
+  duration: number,
+  resolver: string,
+  data: string[],
+  secret: string,
+  reverseRecord: boolean,
+  fuses: string,
+  wrapperExpiry: BigNumberish,
+]
+
 export const randomSecret = () => {
   const bytes = Buffer.allocUnsafe(32)
-  return '0x' + crypto.getRandomValues(bytes).toString('hex')
+  return `0x${crypto.getRandomValues(bytes).toString('hex')}`
 }
 
-export const makeCommitment = ({
+export const makeCommitmentData = ({
   name,
   owner,
   duration,
@@ -19,69 +72,84 @@ export const makeCommitment = ({
   records,
   reverseRecord,
   fuses,
-}: {
-  name: string
-  owner: string
-  duration: number
-  resolver: PublicResolver
-  records?: RecordOptions
-  reverseRecord?: boolean
-  fuses?: FuseOptions
-}) => {
+  wrapperExpiry,
+  secret,
+}: CommitmentParams & {
+  secret: string
+}): CommitmentTuple => {
   const label = labelhash(name.split('.')[0])
   const hash = namehash(name)
   const resolverAddress = resolver.address
-  const data = records ? generateRecordCallArray(hash, records, resolver) : []
-  const secret = randomSecret()
   const fuseData = fuses ? generateFuseInput(fuses) : '0'
 
-  const commitment = _makeCommitment({
-    labelhash: label,
+  if (reverseRecord) {
+    if (!records) {
+      records = { coinTypes: [{ key: 'ETH', value: owner }] }
+    } else if (!records.coinTypes?.find((c) => c.key === 'ETH')) {
+      if (!records.coinTypes) records.coinTypes = []
+      records.coinTypes.push({ key: 'ETH', value: owner })
+    }
+  }
+
+  const data = records ? generateRecordCallArray(hash, records, resolver) : []
+
+  return [
+    label,
     owner,
     duration,
-    secret,
-    resolver: resolverAddress,
+    resolverAddress,
     data,
-    reverseRecord: !!reverseRecord,
-    fuses: fuseData,
+    secret,
+    !!reverseRecord,
+    fuseData,
+    wrapperExpiry || MAX_INT_64,
+  ]
+}
+
+export const makeRegistrationData = (
+  params: RegistrationParams,
+): RegistrationTuple => {
+  const commitmentData = makeCommitmentData(params)
+  const label = params.name.split('.')[0]
+  commitmentData[0] = label
+  const secret = commitmentData.splice(5, 1)[0]
+  commitmentData.splice(3, 0, secret)
+  return commitmentData as unknown as RegistrationTuple
+}
+
+export const _makeCommitment = (params: CommitmentTuple) => {
+  return utils.keccak256(
+    utils.defaultAbiCoder.encode(
+      [
+        'bytes32',
+        'address',
+        'uint256',
+        'address',
+        'bytes[]',
+        'bytes32',
+        'bool',
+        'uint32',
+        'uint64',
+      ],
+      params,
+    ),
+  )
+}
+
+export const makeCommitment = ({
+  secret = randomSecret(),
+  ...inputParams
+}: CommitmentParams) => {
+  const generatedParams = makeCommitmentData({
+    ...inputParams,
+    secret,
   })
 
+  const commitment = _makeCommitment(generatedParams)
+
   return {
     secret,
     commitment,
+    wrapperExpiry: generatedParams[8],
   }
 }
-
-export const _makeCommitment = ({
-  labelhash,
-  owner,
-  duration,
-  secret,
-  resolver,
-  data,
-  reverseRecord,
-  fuses,
-}: {
-  labelhash: string
-  owner: string
-  duration: number
-  secret: string
-  resolver: string
-  data: string[]
-  reverseRecord: boolean
-  fuses: string
-}) => {
-  return utils.solidityKeccak256(
-    [
-      'bytes32',
-      'address',
-      'uint256',
-      'bytes32',
-      'address',
-      'bytes[]',
-      'bool',
-      'uint96',
-    ],
-    [labelhash, owner, duration, secret, resolver, data, reverseRecord, fuses],
-  )
-}

package/src/utils/singleCall.ts

@@ -11,6 +11,6 @@ export default async (
 ) =>
   func
     .raw(ensData, ...data)
-    .then((rawData) => provider.call(rawData))
+    .then((rawData) => provider.call({ ...rawData, ccipReadEnabled: true }))
     .catch(() => null)
     .then((ret) => func.decode(ensData, ret, ...data))

package/src/utils/validation.ts

@@ -4,14 +4,13 @@ import { normalise } from './normalise'
 
 export const validateName = (name: string) => {
   const nameArray = name.split('.')
-  const hasEmptyLabels = nameArray.some((label) => label.length == 0)
+  const hasEmptyLabels = nameArray.some((label) => label.length === 0)
   if (hasEmptyLabels) throw new Error('Name cannot have empty labels')
   const normalizedArray = nameArray.map((label) => {
     if (label === '[root]') {
       return label
-    } else {
-      return isEncodedLabelhash(label) ? label : normalise(label)
     }
+    return isEncodedLabelhash(label) ? label : normalise(label)
   })
   const normalizedName = normalizedArray.join('.')
   saveName(normalizedName)
@@ -30,7 +29,7 @@ type InputType = {
 
 export const parseInputType = (input: string): InputType => {
   const validTLD = validateTLD(input)
-  let regex = /[^.]+$/
+  const regex = /[^.]+$/
 
   try {
     validateName(input)
@@ -61,13 +60,13 @@ export const parseInputType = (input: string): InputType => {
       type: 'name',
       info: 'unsupported',
     }
-  } else if (isAddress(input)) {
+  }
+  if (isAddress(input)) {
     return {
       type: 'address',
     }
-  } else {
-    return {
-      type: 'label',
-    }
+  }
+  return {
+    type: 'label',
   }
 }

package/src/utils/wrapper.ts

@@ -0,0 +1,36 @@
+import { BigNumber } from 'ethers'
+import { toUtf8Bytes } from 'ethers/lib/utils'
+import { ENSArgs } from '../index'
+
+export type Expiry = string | number | Date | BigNumber
+
+export const MAX_EXPIRY = BigNumber.from(2).pow(64).sub(1)
+
+export const makeExpiry = async (
+  { getExpiry }: ENSArgs<'getExpiry'>,
+  name: string,
+  expiry?: Expiry,
+) => {
+  if (expiry) {
+    if (expiry instanceof Date) {
+      return BigNumber.from(expiry.getTime() / 1000)
+    }
+    if (expiry instanceof BigNumber) {
+      return expiry
+    }
+    return BigNumber.from(expiry)
+  }
+  if (name.endsWith('.eth')) {
+    const expResponse = await getExpiry(name)
+    if (!expResponse?.expiry)
+      throw new Error("Couldn't get expiry for name, please provide one.")
+    return BigNumber.from(expResponse.expiry.getTime() / 1000)
+  }
+  return MAX_EXPIRY
+}
+
+export const wrappedLabelLengthCheck = (label: string) => {
+  const bytes = toUtf8Bytes(label)
+  if (bytes.byteLength > 255)
+    throw new Error("Label can't be longer than 255 bytes")
+}

package/src/utils/writeTx.ts

@@ -0,0 +1,16 @@
+import type { JsonRpcSigner } from '@ethersproject/providers'
+import type { PopulatedTransaction } from 'ethers'
+
+type CustomData = Record<string, any>
+
+const withCustomData = <T extends object>(
+  tx: T,
+  customData: CustomData | undefined,
+): (T & { customData: CustomData }) | T =>
+  customData ? { ...tx, customData } : tx
+
+export default (signer: JsonRpcSigner, populate: boolean) =>
+  ({ customData, ...tx }: PopulatedTransaction) =>
+    populate
+      ? withCustomData(tx, customData)
+      : signer.sendTransaction(tx).then((r) => withCustomData(r, customData))

package/dist/cjs/GqlManager.d.ts

@@ -1,6 +0,0 @@
-export default class GqlManager {
-    gql: any;
-    client?: any | null;
-    setUrl: (url: string | null) => Promise<void>;
-    request: (...arg: any[]) => any;
-}