@ensdomains/ensjs 3.0.0-alpha.17 → 3.0.0-alpha.18

package/src/functions/wrapName.test.ts

@@ -4,14 +4,13 @@ import setup from '../tests/setup'
 import { hexEncodeName } from '../utils/hexEncodedName'
 import { namehash } from '../utils/normalise'
 
-let ENSInstance: ENS
+let ensInstance: ENS
 let revert: Awaited<ReturnType<typeof setup>>['revert']
-let createSnapshot: Awaited<ReturnType<typeof setup>>['createSnapshot']
 let provider: ethers.providers.JsonRpcProvider
 let accounts: string[]
 
 beforeAll(async () => {
-  ;({ ENSInstance, revert, createSnapshot, provider } = await setup())
+  ;({ ensInstance, revert, provider } = await setup())
   accounts = await provider.listAccounts()
 })
 
@@ -20,8 +19,8 @@ afterAll(async () => {
 })
 
 const approve = async () => {
-  const nameWrapper = await ENSInstance.contracts!.getNameWrapper()!
-  const registry = (await ENSInstance.contracts!.getRegistry()!).connect(
+  const nameWrapper = await ensInstance.contracts!.getNameWrapper()!
+  const registry = (await ensInstance.contracts!.getRegistry()!).connect(
     provider.getSigner(2),
   )
   const setApprovedForAllTx = await registry.setApprovalForAll(
@@ -37,21 +36,21 @@ describe('wrapName', () => {
   })
   describe('.eth', () => {
     it('should return a wrap name transaction and succeed', async () => {
-      const tx = await ENSInstance.wrapName('test123.eth', {
+      const tx = await ensInstance.wrapName('test123.eth', {
         wrappedOwner: accounts[2],
         addressOrIndex: 1,
       })
       expect(tx).toBeTruthy()
       await tx.wait()
 
-      const nameWrapper = await ENSInstance.contracts!.getNameWrapper()!
+      const nameWrapper = await ensInstance.contracts!.getNameWrapper()!
       const [fuses] = await nameWrapper.getFuses(namehash('test123.eth'))
 
       // parent cannot control
       expect(fuses).toBe(64)
     })
     it('should allow initial fuses', async () => {
-      const tx = await ENSInstance.wrapName('test123.eth', {
+      const tx = await ensInstance.wrapName('test123.eth', {
         wrappedOwner: accounts[2],
         fuseOptions: {
           cannotUnwrap: true,
@@ -62,12 +61,12 @@ describe('wrapName', () => {
       expect(tx).toBeTruthy()
       await tx.wait()
 
-      const nameWrapper = await ENSInstance.contracts!.getNameWrapper()!
+      const nameWrapper = await ensInstance.contracts!.getNameWrapper()!
       const [fuses] = await nameWrapper.getFuses(namehash('test123.eth'))
       expect(fuses).toBe(81)
     })
     it('should allow an initial resolver address', async () => {
-      const tx = await ENSInstance.wrapName('test123.eth', {
+      const tx = await ensInstance.wrapName('test123.eth', {
         wrappedOwner: accounts[2],
         resolverAddress: '0x42D63ae25990889E35F215bC95884039Ba354115',
         addressOrIndex: 1,
@@ -76,7 +75,7 @@ describe('wrapName', () => {
       await tx.wait()
 
       const universalResolver =
-        await ENSInstance.contracts!.getUniversalResolver()!
+        await ensInstance.contracts!.getUniversalResolver()!
       const [result] = await universalResolver.findResolver(
         hexEncodeName('test123.eth'),
       )
@@ -87,14 +86,14 @@ describe('wrapName', () => {
     it('should return a wrap name transaction and succeed', async () => {
       await approve()
 
-      const tx = await ENSInstance.wrapName('test.with-subnames.eth', {
+      const tx = await ensInstance.wrapName('test.with-subnames.eth', {
         wrappedOwner: accounts[2],
         addressOrIndex: 2,
       })
       expect(tx).toBeTruthy()
       await tx.wait()
 
-      const nameWrapper = await ENSInstance.contracts!.getNameWrapper()!
+      const nameWrapper = await ensInstance.contracts!.getNameWrapper()!
       const [fuses] = await nameWrapper.getFuses(
         namehash('test.with-subnames.eth'),
       )
@@ -103,7 +102,7 @@ describe('wrapName', () => {
     })
     it('should allow an initial resolver address', async () => {
       await approve()
-      const tx = await ENSInstance.wrapName('test.with-subnames.eth', {
+      const tx = await ensInstance.wrapName('test.with-subnames.eth', {
         wrappedOwner: accounts[2],
         resolverAddress: '0x42D63ae25990889E35F215bC95884039Ba354115',
         addressOrIndex: 2,
@@ -112,7 +111,7 @@ describe('wrapName', () => {
       await tx.wait()
 
       const universalResolver =
-        await ENSInstance.contracts!.getUniversalResolver()!
+        await ensInstance.contracts!.getUniversalResolver()!
       const [result] = await universalResolver.findResolver(
         hexEncodeName('test.with-subnames.eth'),
       )
@@ -120,7 +119,7 @@ describe('wrapName', () => {
     })
     it('should throw an error if contract does not have approval', async () => {
       await expect(
-        ENSInstance.wrapName('test.with-subnames.eth', {
+        ensInstance.wrapName('test.with-subnames.eth', {
           wrappedOwner: accounts[2],
           addressOrIndex: 2,
         }),
@@ -128,7 +127,7 @@ describe('wrapName', () => {
     })
     it('should throw an error if initial fuses are provided', async () => {
       await expect(
-        ENSInstance.wrapName('test.with-subnames.eth', {
+        ensInstance.wrapName('test.with-subnames.eth', {
           wrappedOwner: accounts[2],
           fuseOptions: {
             cannotUnwrap: true,

package/src/functions/wrapName.ts

@@ -16,7 +16,7 @@ async function wrapETH(
   address: string,
 ) {
   const nameWrapper = await contracts?.getNameWrapper()!
-  const baseRegistrar = (await contracts?.getBaseRegistrar()!).connect(signer)
+  const baseRegistrar = (await contracts!.getBaseRegistrar()!).connect(signer)
 
   const labelhash = ethers.utils.solidityKeccak256(['string'], [labels[0]])
 
@@ -38,7 +38,7 @@ async function wrapOther(
   address: string,
   signer: ethers.Signer,
 ) {
-  const nameWrapper = (await contracts?.getNameWrapper()!).connect(signer)
+  const nameWrapper = (await contracts!.getNameWrapper()!).connect(signer)
   const registry = await contracts?.getRegistry()!
 
   const hasApproval = await registry.isApprovedForAll(
@@ -121,22 +121,21 @@ export default async function (
       signer,
       address,
     )
-  } else {
-    if (fuseOptions)
-      throw new Error(
-        'Fuses can not be initially set when wrapping a non .eth name',
-      )
-    if (expiry)
-      throw new Error(
-        'Expiry can not be initially set when wrapping a non .eth name',
-      )
-    return wrapOther(
-      { contracts },
-      name,
-      wrappedOwner,
-      resolverAddress,
-      address,
-      signer,
-    )
   }
+  if (fuseOptions)
+    throw new Error(
+      'Fuses can not be initially set when wrapping a non .eth name',
+    )
+  if (expiry)
+    throw new Error(
+      'Expiry can not be initially set when wrapping a non .eth name',
+    )
+  return wrapOther(
+    { contracts },
+    name,
+    wrappedOwner,
+    resolverAddress,
+    address,
+    signer,
+  )
 }

package/src/index.ts

@@ -1,4 +1,4 @@
-import { JsonRpcSigner } from '@ethersproject/providers'
+import type { JsonRpcSigner } from '@ethersproject/providers'
 import { ContractTransaction, ethers, PopulatedTransaction } from 'ethers'
 import ContractManager from './contracts'
 import { getContractAddress as _getContractAddress } from './contracts/getContractAddress'
@@ -33,8 +33,8 @@ import type {
   _getText,
 } from './functions/getSpecificRecord'
 import type getSubnames from './functions/getSubnames'
-import registerName from './functions/registerName'
-import renewName from './functions/renewName'
+import type registerName from './functions/registerName'
+import type renewName from './functions/renewName'
 import type setName from './functions/setName'
 import type setRecord from './functions/setRecord'
 import type setRecords from './functions/setRecords'
@@ -46,10 +46,15 @@ import type wrapName from './functions/wrapName'
 import GqlManager from './GqlManager'
 import singleCall from './utils/singleCall'
 import writeTx from './utils/writeTx'
-import fuseEnum from './utils/fuses'
 
-export type { FusePropsNamedArray, FusePropsUnnamedArray, FusePropsNumber, FuseProps, NamedFusesToBurn } from './functions/burnFuses'
-export type FuseEnum = typeof fuseEnum 
+export type {
+  Fuse,
+  FuseArrayPossibilities,
+  FuseObj,
+  NamedFusesToBurn,
+  UnnamedFuseType,
+  UnnamedFuseValues,
+} from './utils/fuses'
 
 type ENSOptions = {
   graphURI?: string | null
@@ -109,12 +114,14 @@ interface WriteFunction<F extends (...args: any) => any> extends Function {
   ) => Promise<PopulatedTransaction>
 }
 
+/* eslint-disable @typescript-eslint/naming-convention */
 const graphURIEndpoints: Record<string, string> = {
   1: 'https://api.thegraph.com/subgraphs/name/ensdomains/ens',
   3: 'https://api.thegraph.com/subgraphs/name/ensdomains/ensropsten',
   4: 'https://api.thegraph.com/subgraphs/name/ensdomains/ensrinkeby',
   5: 'https://api.thegraph.com/subgraphs/name/ensdomains/ensgoerli',
 }
+/* eslint-enable @typescript-eslint/naming-convention */
 
 export type RawFunction = {
   raw: (...args: any[]) => Promise<{ to: string; data: string }>
@@ -154,14 +161,20 @@ export interface GenericGeneratedRawFunction
 
 export class ENS {
   [x: string]: any
+
   protected options?: ENSOptions
+
   protected provider?: ethers.providers.JsonRpcProvider
+
   protected graphURI?: string | null
+
   protected initialProvider?: ethers.providers.JsonRpcProvider
+
   contracts?: ContractManager
+
   getContractAddress = _getContractAddress
+
   gqlInstance = new GqlManager()
-  fuses = fuseEnum
 
   constructor(options?: ENSOptions) {
     this.options = options
@@ -177,7 +190,6 @@ export class ENS {
       return
     }
     await this.setProvider(this.initialProvider)
-    return
   }
 
   /**
@@ -262,20 +274,19 @@ export class ENS {
 
         // return the function with the dependencies forwarded
         return func(dependenciesToForward, ...args)
-      } else {
-        // get the dependencies to forward from raw and decode functions
-        const dependenciesToForward = thisRef.forwardDependenciesFromArray<
-          CombineFunctionDeps<F>
-        >(dependencies as any)
-
-        // return singleCall function with dependencies forwarded
-        return singleCall(
-          thisRef.provider!,
-          dependenciesToForward,
-          mod[exportName],
-          ...args,
-        )
       }
+      // get the dependencies to forward from raw and decode functions
+      const dependenciesToForward = thisRef.forwardDependenciesFromArray<
+        CombineFunctionDeps<F>
+      >(dependencies as any)
+
+      // return singleCall function with dependencies forwarded
+      return singleCall(
+        thisRef.provider!,
+        dependenciesToForward,
+        mod[exportName],
+        ...args,
+      )
     }
 
     // if subfunc is combine, add raw and decode property methods to the function
@@ -383,7 +394,6 @@ export class ENS {
       this.provider,
       this.getContractAddress(String(network) as SupportedNetworkId),
     )
-    return
   }
 
   /**

package/src/utils/contentHash.ts

@@ -26,13 +26,16 @@ function matchProtocol(text: string) {
 }
 
 export function decodeContenthash(encoded: any) {
-  let decoded, protocolType, error
+  let decoded
+  let protocolType
+  let error
   if (!encoded || encoded === '0x') {
     return {}
   }
   if (encoded.error) {
     return { protocolType: null, decoded: encoded.error }
-  } else if (encoded === false) {
+  }
+  if (encoded === false) {
     return { protocolType: null, decoded: 'invalid value' }
   }
   if (encoded) {
@@ -80,12 +83,12 @@ export function isValidContenthash(encoded: any) {
 }
 
 export function getProtocolType(encoded: any) {
-  let protocolType, decoded
+  let protocolType
+  let decoded
   try {
-    let matched = matchProtocol(encoded)
+    const matched = matchProtocol(encoded)
     if (matched) {
-      protocolType = matched[1]
-      decoded = matched[2]
+      ;[, protocolType, decoded] = matched
     }
     return {
       protocolType,
@@ -101,38 +104,37 @@ export function encodeContenthash(text: string) {
   let contentType
   let encoded: string | boolean = false
   let error
-  if (!!text) {
-    let matched = matchProtocol(text)
+  if (text) {
+    const matched = matchProtocol(text)
     if (matched) {
-      contentType = matched[1]
-      content = matched[2]
+      ;[, contentType, content] = matched
     }
     try {
       if (contentType === 'ipfs') {
         if (content.length >= 4) {
-          encoded = '0x' + contentHash.encode('ipfs-ns', content)
+          encoded = `0x${contentHash.encode('ipfs-ns', content)}`
         }
       } else if (contentType === 'ipns') {
-        encoded = '0x' + contentHash.encode('ipns-ns', content)
+        encoded = `0x${contentHash.encode('ipns-ns', content)}`
       } else if (contentType === 'bzz') {
         if (content.length >= 4) {
-          encoded = '0x' + contentHash.fromSwarm(content)
+          encoded = `0x${contentHash.fromSwarm(content)}`
         }
       } else if (contentType === 'onion') {
-        if (content.length == 16) {
-          encoded = '0x' + contentHash.encode('onion', content)
+        if (content.length === 16) {
+          encoded = `0x${contentHash.encode('onion', content)}`
         }
       } else if (contentType === 'onion3') {
-        if (content.length == 56) {
-          encoded = '0x' + contentHash.encode('onion3', content)
+        if (content.length === 56) {
+          encoded = `0x${contentHash.encode('onion3', content)}`
         }
       } else if (contentType === 'sia') {
-        if (content.length == 46) {
-          encoded = '0x' + contentHash.encode('skynet-ns', content)
+        if (content.length === 46) {
+          encoded = `0x${contentHash.encode('skynet-ns', content)}`
         }
       } else if (contentType === 'arweave') {
-        if (content.length == 43) {
-          encoded = '0x' + contentHash.encode('arweave-ns', content)
+        if (content.length === 43) {
+          encoded = `0x${contentHash.encode('arweave-ns', content)}`
         }
       } else {
         console.warn('Unsupported protocol or invalid value', {
@@ -144,7 +146,7 @@ export function encodeContenthash(text: string) {
       const errorMessage = 'Error encoding content hash'
       console.warn(errorMessage, { text, encoded })
       error = errorMessage
-      //throw 'Error encoding content hash'
+      // throw 'Error encoding content hash'
     }
   }
   return { encoded, error }

package/src/utils/createReverseNode.ts

@@ -1,2 +1,2 @@
 export default (address: string) =>
-  address.toLowerCase().substring(2) + '.addr.reverse'
+  `${address.toLowerCase().substring(2)}.addr.reverse`

package/src/utils/fuses.ts

@@ -28,4 +28,43 @@ const fullFuseEnum = {
   CAN_DO_EVERYTHING,
 }
 
+export type FuseObj = typeof fuseEnum
+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 default fullFuseEnum

package/src/utils/normalise.ts

@@ -14,7 +14,7 @@ export const namehash = (name: string): string => {
   if (name) {
     const labels = name.split('.')
 
-    for (var i = labels.length - 1; i >= 0; i--) {
+    for (let i = labels.length - 1; i >= 0; i -= 1) {
       let labelSha: string
       if (isEncodedLabelhash(labels[i])) {
         labelSha = decodeLabelhash(labels[i])

package/src/utils/recordHelpers.ts

@@ -20,7 +20,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()]
@@ -58,19 +58,17 @@ export function generateSingleRecordCall<T extends RecordTypes>(
         _contentHash,
       ])
     }
-  } else {
-    return (_r: RecordInput<T>) => {
-      const record = _r as RecordItem
-      if (type === 'text') {
-        return resolver.interface.encodeFunctionData('setText', [
-          namehash,
-          record.key,
-          record.value,
-        ])
-      } else {
-        return generateSetAddr(namehash, record.key, record.value, resolver)
-      }
+  }
+  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)
   }
 }
 
@@ -87,7 +85,7 @@ export const generateRecordCallArray = (
       resolver,
       'contentHash',
     )(records.contentHash)
-    data && calls.push(data)
+    if (data) calls.push(data)
   }
 
   if (records.texts && records.texts.length > 0) {

package/src/utils/registerHelpers.ts

@@ -52,7 +52,7 @@ export type CommitmentTuple = [
 
 export const randomSecret = () => {
   const bytes = Buffer.allocUnsafe(32)
-  return '0x' + crypto.getRandomValues(bytes).toString('hex')
+  return `0x${crypto.getRandomValues(bytes).toString('hex')}`
 }
 
 export const makeCommitmentData = ({
@@ -101,30 +101,13 @@ export const makeRegistrationData = (
   params: RegistrationParams,
 ): RegistrationTuple => {
   const commitmentData = makeCommitmentData(params)
-  commitmentData[0] = params.name.split('.')[0]
+  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 = ({
-  secret = randomSecret(),
-  ...inputParams
-}: CommitmentParams) => {
-  const generatedParams = makeCommitmentData({
-    ...inputParams,
-    secret,
-  })
-
-  const commitment = _makeCommitment(generatedParams)
-
-  return {
-    secret,
-    commitment,
-    wrapperExpiry: generatedParams[8],
-  }
-}
-
 export const _makeCommitment = (params: CommitmentTuple) => {
   return utils.keccak256(
     utils.defaultAbiCoder.encode(
@@ -143,3 +126,21 @@ export const _makeCommitment = (params: CommitmentTuple) => {
     ),
   )
 }
+
+export const makeCommitment = ({
+  secret = randomSecret(),
+  ...inputParams
+}: CommitmentParams) => {
+  const generatedParams = makeCommitmentData({
+    ...inputParams,
+    secret,
+  })
+
+  const commitment = _makeCommitment(generatedParams)
+
+  return {
+    secret,
+    commitment,
+    wrapperExpiry: generatedParams[8],
+  }
+}

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/wrapperExpiry.ts

@@ -13,19 +13,17 @@ export const makeExpiry = async (
   if (expiry) {
     if (expiry instanceof Date) {
       return BigNumber.from(expiry.getTime() / 1000)
-    } else if (expiry instanceof BigNumber) {
-      return expiry
-    } else {
-      return BigNumber.from(expiry)
     }
-  } else {
-    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)
-    } else {
-      return MAX_EXPIRY
+    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
 }

package/src/utils/writeTx.ts

@@ -1,4 +1,4 @@
-import { JsonRpcSigner } from '@ethersproject/providers'
+import type { JsonRpcSigner } from '@ethersproject/providers'
 import type { PopulatedTransaction } from 'ethers'
 
 type CustomData = Record<string, any>