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

package/src/functions/getHistory.ts

@@ -4,6 +4,30 @@ import { ENSArgs } from '..'
 import { decodeContenthash } from '../utils/contentHash'
 import { labelhash } from '../utils/labels'
 import { namehash } from '../utils/normalise'
+import {
+  AbiChanged,
+  AddrChanged,
+  AuthorisationChanged,
+  ContenthashChanged,
+  ExpiryExtended,
+  FusesSet,
+  InterfaceChanged,
+  MulticoinAddrChanged,
+  NameChanged,
+  NameRegistered,
+  NameRenewed,
+  NameTransferred,
+  NameUnwrapped,
+  NameWrapped,
+  NewOwner,
+  NewResolver,
+  NewTtl,
+  PubkeyChanged,
+  TextChanged,
+  Transfer,
+  VersionChanged,
+  WrappedTransfer,
+} from '../utils/subgraph-types'
 
 type DomainEvent =
   | 'NewOwner'
@@ -14,6 +38,7 @@ type DomainEvent =
   | 'NameWrapped'
   | 'NameUnwrapped'
   | 'FusesSet'
+  | 'ExpiryExtended'
 type RegistrationEvent = 'NameRegistered' | 'NameRenewed' | 'NameTransferred'
 type ResolverEvent =
   | 'AddrChanged'
@@ -38,30 +63,35 @@ const eventFormat: {
   [key in EventTypes]: { [n in EventFormat[key]]: (args: any) => object }
 } = {
   Domain: {
-    NewOwner: (args: any) => ({ owner: args.owner.id }),
-    NewResolver: (args: any) => ({ resolver: args.resolver.id.split('-')[0] }),
-    Transfer: (args: any) => ({ owner: args.owner.id }),
-    NewTTL: (args: any) => ({ ttl: args.ttl }),
-    WrappedTransfer: (args: any) => ({ owner: args.owner.id }),
-    NameWrapped: (args: any) => ({
+    NewOwner: (args: NewOwner) => ({ owner: args.owner.id }),
+    NewResolver: (args: NewResolver) => ({
+      resolver: args.resolver.id.split('-')[0],
+    }),
+    Transfer: (args: Transfer) => ({ owner: args.owner.id }),
+    NewTTL: (args: NewTtl) => ({ ttl: args.ttl }),
+    WrappedTransfer: (args: WrappedTransfer) => ({ owner: args.owner.id }),
+    NameWrapped: (args: NameWrapped) => ({
       fuses: args.fuses,
       owner: args.owner.id,
-      expiry: args.expiry,
+      expiryDate: args.expiryDate,
     }),
-    NameUnwrapped: (args: any) => ({ owner: args.owner.id }),
-    FusesSet: (args: any) => ({ fuses: args.fuses, expiry: args.expiry }),
+    NameUnwrapped: (args: NameUnwrapped) => ({ owner: args.owner.id }),
+    FusesSet: (args: FusesSet) => ({ fuses: args.fuses }),
+    ExpiryExtended: (args: ExpiryExtended) => ({ expiryDate: args.expiryDate }),
   },
   Registration: {
-    NameRegistered: (args: any) => ({
+    NameRegistered: (args: NameRegistered) => ({
       registrant: args.registrant.id,
       expiryDate: args.expiryDate,
     }),
-    NameRenewed: (args: any) => ({ expiryDate: args.expiryDate }),
-    NameTransferred: (args: any) => ({ owner: args.newOwner.id }),
+    NameRenewed: (args: NameRenewed) => ({ expiryDate: args.expiryDate }),
+    NameTransferred: (args: NameTransferred) => ({ owner: args.newOwner.id }),
   },
   Resolver: {
-    AddrChanged: (args: any) => ({ addr: args.addr.id }),
-    MulticoinAddrChanged: (args: any) => {
+    AddrChanged: (args: AddrChanged) => ({ addr: args.addr.id }),
+    MulticoinAddrChanged: (
+      args: Omit<MulticoinAddrChanged, 'addr'> & { multiaddr: string },
+    ) => {
       const format = formatsByCoinType[parseInt(args.coinType)]
       if (!format) {
         return {
@@ -82,21 +112,23 @@ const eventFormat: {
         addr: format.encoder(Buffer.from(args.multiaddr.slice(2), 'hex')),
       }
     },
-    NameChanged: (args: any) => ({ name: args.name }),
-    AbiChanged: (args: any) => ({ contentType: args.contentType }),
-    PubkeyChanged: (args: any) => ({ x: args.x, y: args.y }),
-    TextChanged: (args: any) => ({ key: args.key, value: args.value }),
-    ContenthashChanged: (args: any) => ({ hash: decodeContenthash(args.hash) }),
-    InterfaceChanged: (args: any) => ({
-      interfaceId: args.interfaceId,
+    NameChanged: (args: NameChanged) => ({ name: args.name }),
+    AbiChanged: (args: AbiChanged) => ({ contentType: args.contentType }),
+    PubkeyChanged: (args: PubkeyChanged) => ({ x: args.x, y: args.y }),
+    TextChanged: (args: TextChanged) => ({ key: args.key, value: args.value }),
+    ContenthashChanged: (args: ContenthashChanged) => ({
+      hash: decodeContenthash(args.hash),
+    }),
+    InterfaceChanged: (args: InterfaceChanged) => ({
+      interfaceId: args.interfaceID,
       implementer: args.implementer,
     }),
-    AuthorisationChanged: (args: any) => ({
+    AuthorisationChanged: (args: AuthorisationChanged) => ({
       owner: args.owner,
       target: args.target,
       isAuthorized: args.isAuthorized,
     }),
-    VersionChanged: (args: any) => ({ version: args.version }),
+    VersionChanged: (args: VersionChanged) => ({ version: args.version }),
   },
 }
 
@@ -154,7 +186,7 @@ export async function getHistory(
             }
             ...on NameWrapped {
               fuses
-              expiry
+              expiryDate
               owner {
                 id
               }
@@ -166,7 +198,9 @@ export async function getHistory(
             }
             ...on FusesSet {
               fuses
-              expiry
+            }
+            ...on ExpiryExtended {
+              expiryDate
             }
           }
           registration {

package/src/functions/getNames.test.ts

@@ -29,7 +29,7 @@ const letterItems = [
 ]
 
 const domainLetterItems = [
-  '[',
+  ...Array(3).fill('['),
   'x',
   'w',
   't',
@@ -172,7 +172,7 @@ describe('getNames', () => {
       type: 'wrappedOwner',
       page: 0,
     })
-    expect(pageOne).toHaveLength(1)
+    expect(pageOne).toHaveLength(2)
   })
   describe('orderBy', () => {
     describe('registrations', () => {

package/src/functions/getNames.ts

@@ -1,7 +1,8 @@
 import { ENSArgs } from '..'
 import { truncateFormat } from '../utils/format'
-import { CurrentFuses, decodeFuses } from '../utils/fuses'
+import { AllCurrentFuses, decodeFuses } from '../utils/fuses'
 import { decryptName } from '../utils/labels'
+import { Domain, Registration, WrappedDomain } from '../utils/subgraph-types'
 
 export type Name = {
   id: string
@@ -16,7 +17,7 @@ export type Name = {
   createdAt?: Date
   registrationDate?: Date
   expiryDate?: Date
-  fuses?: CurrentFuses
+  fuses?: AllCurrentFuses
   registration?: {
     expiryDate: Date
     registrationDate: Date
@@ -44,7 +45,7 @@ type OwnerParams = {
 
 type WrappedOwnerParams = {
   type: 'wrappedOwner'
-  orderBy?: 'expiryDate' | 'labelName'
+  orderBy?: 'expiryDate' | 'name'
 }
 
 type AllParams = {
@@ -57,23 +58,35 @@ type AllParams = {
 type Params = BaseParams &
   (RegistrantParams | OwnerParams | WrappedOwnerParams | AllParams)
 
-const mapDomain = (domain: any) => {
-  const decrypted = decryptName(domain.name)
+const mapDomain = ({ name, ...domain }: Domain) => {
+  const decrypted = name ? decryptName(name) : undefined
   return {
     ...domain,
     name: decrypted,
-    truncatedName: truncateFormat(decrypted),
+    truncatedName: decrypted ? truncateFormat(decrypted) : undefined,
     createdAt: new Date(parseInt(domain.createdAt) * 1000),
     type: 'domain',
   }
 }
 
-const mapWrappedDomain = (wrappedDomain: any) => {
-  const domain = mapDomain(wrappedDomain.domain)
+const mapWrappedDomain = (wrappedDomain: WrappedDomain) => {
+  const domain = mapDomain(wrappedDomain.domain) as Omit<
+    ReturnType<typeof mapDomain>,
+    'registration'
+  > & {
+    registration?: {
+      expiryDate: string | Date
+      registrationDate: string | Date
+    }
+  }
   if (domain.registration) {
     domain.registration = {
-      expiryDate: new Date(parseInt(domain.registration.expiryDate) * 1000),
-      registrationDate: new Date(domain.registration.registrationDate * 1000),
+      expiryDate: new Date(
+        parseInt(domain.registration.expiryDate as string) * 1000,
+      ),
+      registrationDate: new Date(
+        parseInt(domain.registration.registrationDate as string) * 1000,
+      ),
     }
   }
   return {
@@ -84,8 +97,8 @@ const mapWrappedDomain = (wrappedDomain: any) => {
   }
 }
 
-const mapRegistration = (registration: any) => {
-  const decrypted = decryptName(registration.domain.name)
+const mapRegistration = (registration: Registration) => {
+  const decrypted = decryptName(registration.domain.name!)
   return {
     expiryDate: new Date(parseInt(registration.expiryDate) * 1000),
     registrationDate: new Date(parseInt(registration.registrationDate) * 1000),
@@ -275,7 +288,7 @@ const getNames = async (
         id: address,
         first: pageSize,
         skip: (page || 0) * pageSize,
-        orderBy,
+        orderBy: orderBy === 'labelName' ? 'name' : orderBy,
         orderDirection,
       }
     }

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

@@ -1,5 +1,5 @@
-import { defaultAbiCoder } from '@ethersproject/abi/lib/abi-coder'
-import type { Result } from '@ethersproject/abi/lib/coders/abstract-coder'
+import type { Result } from '@ethersproject/abi'
+import { defaultAbiCoder } from '@ethersproject/abi'
 import { hexStripZeros } from '@ethersproject/bytes'
 import { ENSArgs } from '..'
 import { labelhash } from '../utils/labels'
@@ -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/getPrice.ts

@@ -1,5 +1,5 @@
-import { defaultAbiCoder } from '@ethersproject/abi/lib/abi-coder'
-import { BigNumber } from '@ethersproject/bignumber/lib/bignumber'
+import { defaultAbiCoder } from '@ethersproject/abi'
+import { BigNumber } from '@ethersproject/bignumber'
 import { ENSArgs } from '..'
 
 const raw = async (

package/src/functions/getProfile.test.ts

@@ -119,6 +119,13 @@ describe('getProfile', () => {
         deploymentAddresses.LegacyPublicResolver,
       )
     })
+    it('should return the decoded name for a name with encoded labels', async () => {
+      const result = await ensInstance.getProfile(
+        '[9dd2c369a187b4e6b9c402f030e50743e619301ea62aa4c0737d4ef7e10a3d49].with-subnames.eth',
+      )
+      expect(result).toBeDefined()
+      expect(result?.decryptedName).toBe('xyz.with-subnames.eth')
+    })
     it('should return undefined for an unregistered name', async () => {
       const result = await ensInstance.getProfile('test123123123cool.eth')
       expect(result).toBeUndefined()

package/src/functions/getProfile.ts

@@ -1,5 +1,5 @@
 import { formatsByName } from '@ensdomains/address-encoder'
-import { defaultAbiCoder } from '@ethersproject/abi/lib/abi-coder'
+import { defaultAbiCoder } from '@ethersproject/abi'
 import { hexStripZeros, isBytesLike } from '@ethersproject/bytes'
 import { ENSArgs } from '..'
 import { decodeContenthash, DecodedContentHash } from '../utils/contentHash'
@@ -37,6 +37,7 @@ type ResolvedProfile = {
   createdAt: string | null
   address?: string
   name?: string | null
+  decryptedName?: string | null
   match?: boolean
   message?: string
   records?: {
@@ -360,6 +361,7 @@ const graphFetch = async (
   const query = gqlInstance.gql`
     query getRecords($id: String!) {
       domain(id: $id) {
+        name
         isMigrated
         createdAt
         resolver {
@@ -377,6 +379,7 @@ const graphFetch = async (
   const customResolverQuery = gqlInstance.gql`
     query getRecordsWithCustomResolver($id: String!, $resolverId: String!) {
       domain(id: $id) {
+        name
         isMigrated
         createdAt
       }
@@ -414,11 +417,12 @@ const graphFetch = async (
 
   if (!domain) return
 
-  const { isMigrated, createdAt } = domain
+  const { isMigrated, createdAt, name: decryptedName } = domain
 
   const returnedRecords: ProfileResponse = {}
 
-  if (!resolverResponse || !wantedRecords) return { isMigrated, createdAt }
+  if (!resolverResponse || !wantedRecords)
+    return { isMigrated, createdAt, decryptedName }
 
   Object.keys(wantedRecords).forEach((key: string) => {
     const data = wantedRecords[key as keyof ProfileOptions]
@@ -433,6 +437,7 @@ const graphFetch = async (
 
   return {
     ...returnedRecords,
+    decryptedName,
     isMigrated,
     createdAt,
   }
@@ -486,6 +491,7 @@ const getProfileFromName = async (
   )
   let isMigrated: boolean | null = null
   let createdAt: string | null = null
+  let decryptedName: string | null = null
   let result: Awaited<ReturnType<typeof getDataForName>> | null = null
   if (!graphResult) {
     if (!fallback) return
@@ -506,13 +512,16 @@ const getProfileFromName = async (
     const {
       isMigrated: _isMigrated,
       createdAt: _createdAt,
+      decryptedName: _decryptedName,
       ...wantedRecords
     }: {
       isMigrated: boolean
       createdAt: string
+      decryptedName: string
     } & InternalProfileOptions = graphResult
     isMigrated = _isMigrated
     createdAt = _createdAt
+    decryptedName = _decryptedName
     let recordsWithFallback = usingOptions
       ? wantedRecords
       : (_options as InternalProfileOptions)
@@ -547,7 +556,7 @@ const getProfileFromName = async (
         ? "Records fetch didn't complete"
         : "Name doesn't have a resolver",
     }
-  return { ...result, isMigrated, createdAt, message: undefined }
+  return { ...result, isMigrated, createdAt, decryptedName, message: undefined }
 }
 
 const getProfileFromAddress = async (

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

@@ -1,4 +1,4 @@
-import { BigNumber } from '@ethersproject/bignumber/lib/bignumber'
+import { BigNumber } from '@ethersproject/bignumber'
 import { ENSArgs } from '../index'
 import { decodeFuses } from '../utils/fuses'
 import { namehash } from '../utils/normalise'
@@ -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/registerName.ts

@@ -1,4 +1,4 @@
-import { BigNumber } from '@ethersproject/bignumber/lib/bignumber'
+import { BigNumber } from '@ethersproject/bignumber'
 import { ENSArgs } from '..'
 import {
   BaseRegistrationParams,