@ensdomains/ensjs 3.0.0-alpha.41 → 3.0.0-alpha.42

package/src/functions/getOwner.test.ts

@@ -1,11 +1,15 @@
+import { JsonRpcProvider } from '@ethersproject/providers'
 import { ENS } from '..'
 import setup from '../tests/setup'
 
 let ensInstance: ENS
 let revert: Awaited<ReturnType<typeof setup>>['revert']
+let provider: JsonRpcProvider
+let accounts: string[]
 
 beforeAll(async () => {
-  ;({ ensInstance, revert } = await setup())
+  ;({ ensInstance, revert, provider } = await setup())
+  accounts = await provider.listAccounts()
 })
 
 afterAll(async () => {
@@ -13,8 +17,63 @@ afterAll(async () => {
 })
 
 describe('getOwner', () => {
-  it('should return nameWrapper as the ownership level for a wrapped name', async () => {
+  it('should return correct ownership level and values for a wrapped .eth name', async () => {
     const result = await ensInstance.getOwner('wrapped.eth')
-    expect(result?.ownershipLevel).toBe('nameWrapper')
+    expect(result).toEqual({
+      ownershipLevel: 'nameWrapper',
+      owner: accounts[1],
+      expired: false,
+    })
+  })
+  it('should return correct ownership level and values for an expired wrapped .eth name', async () => {
+    const result = await ensInstance.getOwner('expired-wrapped.eth')
+    expect(result).toEqual({
+      ownershipLevel: 'nameWrapper',
+      owner: '0x0000000000000000000000000000000000000000',
+      expired: true,
+    })
+  })
+  it('should return correct ownership level and values for an unwrapped .eth name', async () => {
+    const result = await ensInstance.getOwner('test123.eth')
+    expect(result).toEqual({
+      ownershipLevel: 'registrar',
+      owner: accounts[1],
+      registrant: accounts[1],
+      expired: false,
+    })
+  })
+  it('should return correct ownership level and values for an expired unwrapped .eth name', async () => {
+    const result = await ensInstance.getOwner('expired.eth')
+    expect(result).toEqual({
+      ownershipLevel: 'registrar',
+      owner: accounts[1],
+      registrant: accounts[1].toLowerCase(),
+      expired: true,
+    })
+  })
+  describe('subname', () => {
+    it('should return correct ownership level and values for a unwrapped name', async () => {
+      const result = await ensInstance.getOwner('test.with-subnames.eth')
+      expect(result).toEqual({
+        ownershipLevel: 'registry',
+        owner: accounts[2],
+      })
+    })
+    it('should return correct ownership level and values for a wrapped name', async () => {
+      const result = await ensInstance.getOwner(
+        'test.wrapped-with-subnames.eth',
+      )
+      expect(result).toEqual({
+        ownershipLevel: 'nameWrapper',
+        owner: accounts[2],
+      })
+    })
+    it('should return correct ownership level and values for an expired wrapped name', async () => {
+      const result = await ensInstance.getOwner('test.expired-wrapped.eth')
+      expect(result).toEqual({
+        ownershipLevel: 'nameWrapper',
+        owner: accounts[2],
+      })
+    })
   })
 })

package/src/functions/getOwner.ts

@@ -9,6 +9,7 @@ type Owner = {
   registrant?: string
   owner?: string
   ownershipLevel: 'nameWrapper' | 'registry' | 'registrar'
+  expired?: boolean
 }
 
 const singleContractOwnerRaw = async (
@@ -146,26 +147,43 @@ const decode = async (
 
   const registryOwner = (decodedData[0] as Result)[0]
   const nameWrapperOwner = (decodedData[1] as Result)[0]
-  let registrarOwner = (decodedData[2] as Result | undefined)?.[0]
+  let registrarOwner: string | undefined = (
+    decodedData[2] as Result | undefined
+  )?.[0]
+  let baseReturnObject: {
+    expired?: boolean
+  } = {}
 
   // check for only .eth names
   if (labels[labels.length - 1] === 'eth') {
-    if (!registrarOwner && labels.length === 2) {
-      const graphRegistrantResult = await gqlInstance.client.request(
-        registrantQuery,
-        {
-          namehash: makeNamehash(name),
-        },
-      )
-      registrarOwner =
-        graphRegistrantResult.domain?.registration?.registrant?.id
+    // if there is no registrar owner, the name is expired
+    // but we still want to get the registrar owner prior to expiry
+    if (labels.length === 2) {
+      if (!registrarOwner) {
+        const graphRegistrantResult = await gqlInstance.client.request(
+          registrantQuery,
+          {
+            namehash: makeNamehash(name),
+          },
+        )
+        registrarOwner =
+          graphRegistrantResult.domain?.registration?.registrant?.id
+        baseReturnObject = {
+          expired: true,
+        }
+      } else {
+        baseReturnObject = {
+          expired: false,
+        }
+      }
     }
     // if the owner on the registrar is the namewrapper, then the namewrapper owner is the owner
     // there is no "registrant" for wrapped names
-    if (registrarOwner === nameWrapper.address) {
+    if (registrarOwner?.toLowerCase() === nameWrapper.address.toLowerCase()) {
       return {
         owner: nameWrapperOwner,
         ownershipLevel: 'nameWrapper',
+        ...baseReturnObject,
       }
     }
     // if there is a registrar owner, then it's not a subdomain but we have also passed the namewrapper clause
@@ -177,6 +195,7 @@ const decode = async (
         registrant: registrarOwner,
         owner: registryOwner,
         ownershipLevel: 'registrar',
+        ...baseReturnObject,
       }
     }
     if (hexStripZeros(registryOwner) !== '0x') {
@@ -187,6 +206,7 @@ const decode = async (
           registrant: undefined,
           owner: registryOwner,
           ownershipLevel: 'registrar',
+          expired: true,
         }
       }
       // this means that the subname is wrapped

package/src/functions/getWrapperData.test.ts

@@ -1,4 +1,3 @@
-import { BigNumber } from 'ethers'
 import { ENS } from '../index'
 import setup from '../tests/setup'
 
@@ -7,22 +6,6 @@ let revert: Awaited<ReturnType<typeof setup>>['revert']
 let createSnapshot: Awaited<ReturnType<typeof setup>>['createSnapshot']
 let withWrappedSnapshot: any
 
-const unwrappedNameDefault = {
-  expiryDate: new Date(0).toString(),
-  fuseObj: {
-    CANNOT_BURN_FUSES: false,
-    CANNOT_CREATE_SUBDOMAIN: false,
-    CANNOT_SET_RESOLVER: false,
-    CANNOT_SET_TTL: false,
-    CANNOT_TRANSFER: false,
-    CANNOT_UNWRAP: false,
-    PARENT_CANNOT_CONTROL: false,
-    CAN_DO_EVERYTHING: true,
-  },
-  owner: '0x0000000000000000000000000000000000000000',
-  rawFuses: BigNumber.from(0),
-}
-
 beforeAll(async () => {
   ;({ ensInstance, revert, createSnapshot } = await setup())
 
@@ -41,9 +24,9 @@ afterAll(async () => {
 describe('getWrapperData', () => {
   it('should return default data for an unwrapped name', async () => {
     const result = await ensInstance.getWrapperData('with-profile.eth')
-    expect({ ...result, expiryDate: result?.expiryDate.toString() }).toEqual(
-      unwrappedNameDefault,
-    )
+    expect(result?.expiryDate).toBeUndefined()
+    expect(result?.rawFuses).toEqual(0)
+    expect(result?.child.CAN_DO_EVERYTHING).toBeTruthy()
   })
   it('should return with CAN_DO_EVERYTHING set to true for a name with no fuses burned', async () => {
     const result = await ensInstance.getWrapperData(
@@ -51,23 +34,13 @@ describe('getWrapperData', () => {
     )
     expect(result).toBeTruthy()
     if (result) {
-      expect(result.fuseObj.CAN_DO_EVERYTHING).toBe(true)
-      expect(
-        Object.values(result.fuseObj).reduce(
-          (prev, curr) => (curr ? prev + 1 : prev),
-          0,
-        ),
-      ).toBe(1)
-      expect(result.rawFuses.toHexString()).toBe('0x00')
+      expect(result.child.CAN_DO_EVERYTHING).toBe(true)
+      expect(result.rawFuses).toBe(0)
     }
   })
   it('should return with other correct fuses', async () => {
-    const tx = await ensInstance.burnFuses('wrapped.eth', {
-      namedFusesToBurn: [
-        'CANNOT_UNWRAP',
-        'CANNOT_CREATE_SUBDOMAIN',
-        'CANNOT_SET_TTL',
-      ],
+    const tx = await ensInstance.setFuses('wrapped.eth', {
+      named: ['CANNOT_UNWRAP', 'CANNOT_CREATE_SUBDOMAIN', 'CANNOT_SET_TTL'],
       addressOrIndex: 1,
     })
     await tx.wait()
@@ -75,17 +48,10 @@ describe('getWrapperData', () => {
     const result = await ensInstance.getWrapperData('wrapped.eth')
     expect(result).toBeTruthy()
     if (result) {
-      expect(result.fuseObj).toMatchObject({
-        CANNOT_UNWRAP: true,
-        CANNOT_BURN_FUSES: false,
-        CANNOT_TRANSFER: false,
-        CANNOT_SET_RESOLVER: false,
-        CANNOT_SET_TTL: true,
-        CANNOT_CREATE_SUBDOMAIN: true,
-        PARENT_CANNOT_CONTROL: true,
-        CAN_DO_EVERYTHING: false,
-      })
-      expect(result.rawFuses.toHexString()).toBe('0x71')
+      expect(result.child.CAN_DO_EVERYTHING).toBe(false)
+      expect(result.child.CANNOT_UNWRAP).toBe(true)
+      expect(result.child.CANNOT_CREATE_SUBDOMAIN).toBe(true)
+      expect(result.child.CANNOT_SET_TTL).toBe(true)
     }
   })
   it('should return correct expiry', async () => {

package/src/functions/getWrapperData.ts

@@ -14,18 +14,20 @@ const raw = async ({ contracts }: ENSArgs<'contracts'>, name: string) => {
 const decode = async ({ contracts }: ENSArgs<'contracts'>, data: string) => {
   const nameWrapper = await contracts?.getNameWrapper()!
   try {
-    const [owner, _fuses, expiry] = nameWrapper.interface.decodeFunctionResult(
+    const [owner, fuses, expiry] = nameWrapper.interface.decodeFunctionResult(
       'getData',
       data,
-    )
+    ) as [string, number, BigNumber]
 
-    const fuses = BigNumber.from(_fuses)
     const fuseObj = decodeFuses(fuses)
 
-    const expiryDate = new Date(expiry * 1000)
+    const expiryDate =
+      expiry.gt(0) && expiry.lt(BigNumber.from(2).pow(32))
+        ? new Date(expiry.mul(1000).toString())
+        : undefined
 
     return {
-      fuseObj,
+      ...fuseObj,
       expiryDate,
       rawFuses: fuses,
       owner,

package/src/functions/registerName.test.ts

@@ -23,6 +23,8 @@ describe('registerName', () => {
     await revert()
   })
   it('should return a registration transaction and succeed', async () => {
+    const controller = await ensInstance.contracts!.getEthRegistrarController()!
+
     const name = 'cool-swag.eth'
     const duration = 31536000
     const { customData, ...commitPopTx } =
@@ -37,14 +39,12 @@ describe('registerName', () => {
     await provider.send('evm_increaseTime', [60])
     await provider.send('evm_mine', [])
 
-    const { secret, wrapperExpiry } = customData!
+    const { secret } = customData!
 
-    const controller = await ensInstance.contracts!.getEthRegistrarController()!
     const [price] = await controller.rentPrice(name, duration)
 
     const tx = await ensInstance.registerName(name, {
       secret,
-      wrapperExpiry,
       duration,
       owner: accounts[1],
       addressOrIndex: accounts[1],

package/src/functions/renewNames.ts

@@ -1,39 +1,33 @@
 import { BigNumber, BigNumberish } from '@ethersproject/bignumber/lib/bignumber'
 import { ENSArgs } from '..'
-import { FuseProps, validateFuses } from '../utils/fuses'
-import { MAX_INT_64 } from '../utils/registerHelpers'
+import { MAX_INT_64 } from '../utils/consts'
+import { labelhash } from '../utils/labels'
+import { namehash } from '../utils/normalise'
 
 type BaseProps = {
   duration: number
   value: BigNumber
 }
 
-export async function renewNameWithData(
+type WrappedProps = {
+  duration: BigNumberish
+}
+
+export async function extendWrappedName(
   { contracts }: ENSArgs<'contracts'>,
   name: string,
-  {
-    duration,
-    value,
-    fuses,
-    wrapperExpiry = MAX_INT_64,
-  }: BaseProps & {
-    fuses?: FuseProps
-    wrapperExpiry?: BigNumberish
-  },
+  options?: WrappedProps,
 ) {
+  const expiry = options?.duration || MAX_INT_64
   const labels = name.split('.')
-  if (labels.length !== 2 || labels[1] !== 'eth') {
-    throw new Error('Currently only .eth TLD renewals are supported')
-  }
+  const labelHash = labelhash(labels.shift()!)
+  const parentNode = namehash(labels.join('.'))
 
-  const encodedFuses = fuses ? validateFuses(fuses) : 0
-  const controller = await contracts!.getEthRegistrarController()
-  return controller.populateTransaction.renewWithFuses(
-    labels[0],
-    duration,
-    encodedFuses,
-    wrapperExpiry,
-    { value },
+  const nameWrapper = await contracts!.getNameWrapper()
+  return nameWrapper.populateTransaction.extendExpiry(
+    parentNode,
+    labelHash,
+    expiry,
   )
 }
 

package/src/functions/setFuses.test.ts

@@ -0,0 +1,240 @@
+import { ethers } from 'ethers'
+import { ENS } from '../index'
+import setup from '../tests/setup'
+import { unnamedUserSettableFuses, userSettableFuseEnum } from '../utils/fuses'
+import { namehash } from '../utils/normalise'
+
+let ensInstance: ENS
+let revert: Awaited<ReturnType<typeof setup>>['revert']
+let provider: ethers.providers.JsonRpcProvider
+let accounts: string[]
+
+beforeAll(async () => {
+  ;({ ensInstance, revert, provider } = await setup())
+  accounts = await provider.listAccounts()
+})
+
+afterAll(async () => {
+  await revert()
+})
+
+const checkFuses = (
+  fuses: number,
+  expected: (keyof typeof userSettableFuseEnum)[],
+) => {
+  // eslint-disable-next-line guard-for-in
+  for (const fuse in userSettableFuseEnum) {
+    const active =
+      (fuses &
+        userSettableFuseEnum[fuse as keyof typeof userSettableFuseEnum]) >
+      0
+    if (expected.includes(fuse as keyof typeof userSettableFuseEnum)) {
+      try {
+        expect(active).toBeTruthy()
+      } catch {
+        throw new Error(`${fuse} should be true but is false`)
+      }
+    } else if (active) {
+      try {
+        expect(active).toBeFalsy()
+      } catch {
+        throw new Error(`${fuse} should be false but is true`)
+      }
+    }
+  }
+}
+
+const checkUnnamedFuses = (
+  fuses: number,
+  expected: (keyof typeof unnamedUserSettableFuses)[],
+) => {
+  // eslint-disable-next-line guard-for-in
+  for (const fuse of unnamedUserSettableFuses) {
+    const active = (fuses & fuse) > 0
+    if (expected.includes(fuse as keyof typeof unnamedUserSettableFuses)) {
+      try {
+        expect(active).toBeTruthy()
+      } catch {
+        throw new Error(`${fuse} should be true but is false`)
+      }
+    } else if (active) {
+      try {
+        expect(active).toBeFalsy()
+      } catch {
+        throw new Error(`${fuse} should be false but is true`)
+      }
+    }
+  }
+}
+
+describe('setFuses', () => {
+  beforeEach(async () => {
+    await revert()
+  })
+  describe('Array', () => {
+    it('should return a setFuses transaction from a named fuse array and succeed', async () => {
+      const tx = await ensInstance.setFuses('wrapped.eth', {
+        named: ['CANNOT_UNWRAP', 'CANNOT_CREATE_SUBDOMAIN', 'CANNOT_SET_TTL'],
+        addressOrIndex: accounts[1],
+      })
+      expect(tx).toBeTruthy()
+      await tx.wait()
+
+      const nameWrapper = await ensInstance.contracts!.getNameWrapper()!
+      const [, fuses] = await nameWrapper.getData(namehash('wrapped.eth'))
+      checkFuses(fuses, [
+        'CANNOT_UNWRAP',
+        'CANNOT_CREATE_SUBDOMAIN',
+        'CANNOT_SET_TTL',
+        'PARENT_CANNOT_CONTROL',
+      ])
+    })
+    it('should return a setFuses transaction from an unnamed fuse array and succeed', async () => {
+      const tx0 = await ensInstance.setFuses('wrapped.eth', {
+        named: ['CANNOT_UNWRAP'],
+        addressOrIndex: accounts[1],
+      })
+      expect(tx0).toBeTruthy()
+      await tx0.wait()
+
+      const tx = await ensInstance.setFuses('wrapped.eth', {
+        unnamed: [128, 256, 512],
+        addressOrIndex: accounts[1],
+      })
+      expect(tx).toBeTruthy()
+      await tx.wait()
+
+      const nameWrapper = await ensInstance.contracts!.getNameWrapper()!
+      const [, fuses] = await nameWrapper.getData(namehash('wrapped.eth'))
+      checkUnnamedFuses(fuses, [128, 256, 512])
+    })
+    it('should return a setFuses transaction from both an unnamed and named fuse array and succeed', async () => {
+      const tx = await ensInstance.setFuses('wrapped.eth', {
+        named: ['CANNOT_UNWRAP', 'CANNOT_CREATE_SUBDOMAIN', 'CANNOT_SET_TTL'],
+        unnamed: [128, 256, 512],
+        addressOrIndex: accounts[1],
+      })
+      expect(tx).toBeTruthy()
+      await tx.wait()
+
+      const nameWrapper = await ensInstance.contracts!.getNameWrapper()!
+      const [, fuses] = await nameWrapper.getData(namehash('wrapped.eth'))
+      checkFuses(fuses, [
+        'CANNOT_UNWRAP',
+        'CANNOT_CREATE_SUBDOMAIN',
+        'CANNOT_SET_TTL',
+        'PARENT_CANNOT_CONTROL',
+      ])
+      checkUnnamedFuses(fuses, [128, 256, 512])
+    })
+    it('should throw an error when trying to burn a named fuse in an unnamed fuse array', async () => {
+      try {
+        await ensInstance.setFuses('wrapped.eth', {
+          unnamed: [32] as any,
+          addressOrIndex: accounts[1],
+        })
+        expect(false).toBeTruthy()
+      } catch (e: any) {
+        expect(e.message).toBe(
+          '32 is not a valid unnamed fuse. If you are trying to set a named fuse, use the named property.',
+        )
+      }
+    })
+    it('should throw an error when trying to burn an unnamed fuse in a named fuse array', async () => {
+      try {
+        await ensInstance.setFuses('wrapped.eth', {
+          named: ['COOL_SWAG_FUSE'] as any,
+        })
+        expect(false).toBeTruthy()
+      } catch (e: any) {
+        expect(e.message).toBe('COOL_SWAG_FUSE is not a valid named fuse.')
+      }
+    })
+  })
+  describe('Number', () => {
+    it('should return a setFuses transaction from a number and succeed', async () => {
+      const tx = await ensInstance.setFuses('wrapped.eth', {
+        number: 49,
+        addressOrIndex: accounts[1],
+      })
+      expect(tx).toBeTruthy()
+      await tx.wait()
+
+      const nameWrapper = await ensInstance.contracts!.getNameWrapper()!
+      const [, fuses] = await nameWrapper.getData(namehash('wrapped.eth'))
+      checkFuses(fuses, [
+        'CANNOT_UNWRAP',
+        'CANNOT_CREATE_SUBDOMAIN',
+        'CANNOT_SET_TTL',
+        'PARENT_CANNOT_CONTROL',
+      ])
+    })
+    it('should throw an error if the number is too high', async () => {
+      try {
+        await ensInstance.setFuses('wrapped.eth', {
+          number: 4294967297,
+          addressOrIndex: accounts[1],
+        })
+        expect(false).toBeTruthy()
+      } catch (e: any) {
+        expect(e.message).toBe(
+          'Fuse number must be limited to uint32, 4294967297 was too high.',
+        )
+      }
+    })
+    it('should throw an error if the number is too low', async () => {
+      try {
+        await ensInstance.setFuses('wrapped.eth', {
+          number: -1,
+          addressOrIndex: accounts[1],
+        })
+        expect(false).toBeTruthy()
+      } catch (e: any) {
+        expect(e.message).toBe(
+          'Fuse number must be limited to uint32, -1 was too low.',
+        )
+      }
+    })
+    it('should throw an error if the number is not an integer', async () => {
+      try {
+        await ensInstance.setFuses('wrapped.eth', {
+          number: 7.5,
+        })
+        expect(false).toBeTruthy()
+      } catch (e: any) {
+        expect(e.message).toBe('Fuse number must be an integer, 7.5 was not.')
+      }
+    })
+  })
+})
+
+describe('setChildFuses', () => {
+  it('should return a setChildFuses transaction and succeed', async () => {
+    const nameWrapper = await ensInstance.contracts!.getNameWrapper()!
+    const setParentTx = await ensInstance.setFuses(
+      'wrapped-with-subnames.eth',
+      {
+        named: ['CANNOT_UNWRAP'],
+        addressOrIndex: accounts[1],
+      },
+    )
+    expect(setParentTx).toBeTruthy()
+    await setParentTx.wait()
+
+    const tx = await ensInstance.setChildFuses(
+      'test.wrapped-with-subnames.eth',
+      {
+        fuses: 65537,
+        addressOrIndex: accounts[1],
+      },
+    )
+    expect(tx).toBeTruthy()
+    await tx.wait()
+
+    const [, fuses] = await nameWrapper.getData(
+      namehash('test.wrapped-with-subnames.eth'),
+    )
+
+    checkFuses(fuses, ['CANNOT_UNWRAP', 'PARENT_CANNOT_CONTROL'])
+  })
+})

package/src/functions/setFuses.ts

@@ -0,0 +1,44 @@
+import { ENSArgs } from '../index'
+import { CombinedFuseInput, encodeFuses } from '../utils/fuses'
+import { labelhash } from '../utils/labels'
+import { namehash } from '../utils/normalise'
+
+export async function setChildFuses(
+  { contracts, signer }: ENSArgs<'contracts' | 'signer'>,
+  name: string,
+  {
+    fuses,
+    expiry = 0,
+  }: {
+    fuses: Partial<CombinedFuseInput> | number
+    expiry?: number
+  },
+) {
+  const encodedFuses = encodeFuses(fuses)
+
+  const labels = name.split('.')
+  const labelHash = labelhash(labels.shift()!)
+  const parentNode = namehash(labels.join('.'))
+
+  const nameWrapper = (await contracts!.getNameWrapper()!).connect(signer)
+
+  return nameWrapper.populateTransaction.setChildFuses(
+    parentNode,
+    labelHash,
+    encodedFuses,
+    expiry,
+  )
+}
+
+export default async function (
+  { contracts, signer }: ENSArgs<'contracts' | 'signer'>,
+  name: string,
+  props: CombinedFuseInput['child'],
+) {
+  const encodedFuses = encodeFuses(props, 'child')
+
+  const nameWrapper = (await contracts!.getNameWrapper()!).connect(signer)
+  const hash = namehash(name)
+
+  return nameWrapper.populateTransaction.setFuses(hash, encodedFuses)
+}

package/src/functions/types.ts

@@ -4,7 +4,6 @@ import type {
   resolverMulticallWrapper,
   universalWrapper,
 } from './batchWrappers'
-import type burnFuses from './burnFuses'
 import type commitName from './commitName'
 import type createSubname from './createSubname'
 import type deleteSubname from './deleteSubname'
@@ -36,8 +35,10 @@ import type registerName from './registerName'
 import type {
   // eslint-disable-next-line import/no-named-default
   default as renewNames,
-  renewNameWithData,
+  extendWrappedName,
 } from './renewNames'
+import type setFuses from './setFuses'
+import type { setChildFuses } from './setFuses'
 import type setName from './setName'
 import type setRecord from './setRecord'
 import type setRecords from './setRecords'
@@ -54,7 +55,8 @@ type Function = {
   multicallWrapper: typeof multicallWrapper
   resolverMulticallWrapper: typeof resolverMulticallWrapper
   universalWrapper: typeof universalWrapper
-  burnFuses: typeof burnFuses
+  setFuses: typeof setFuses
+  setChildFuses: typeof setChildFuses
   commitName: typeof commitName
   createSubname: typeof createSubname
   deleteSubname: typeof deleteSubname
@@ -82,7 +84,7 @@ type Function = {
   importDNSSECName: typeof importDNSSECName
   registerName: typeof registerName
   renewNames: typeof renewNames
-  renewNameWithData: typeof renewNameWithData
+  extendWrappedName: typeof extendWrappedName
   setName: typeof setName
   setRecord: typeof setRecord
   setRecords: typeof setRecords