@ensdomains/ensjs 3.0.0-alpha.45 → 3.0.0-alpha.47

package/src/functions/getSubnames.ts

@@ -1,20 +1,36 @@
 import { ENSArgs } from '..'
 import { truncateFormat } from '../utils/format'
+import { AllCurrentFuses, checkPCCBurned, decodeFuses } from '../utils/fuses'
 import { decryptName } from '../utils/labels'
 import { namehash } from '../utils/normalise'
+import { Domain } from '../utils/subgraph-types'
 
-type Subname = {
+type BaseSubname = {
   id: string
   labelName: string | null
   truncatedName?: string
   labelhash: string
   isMigrated: boolean
   name: string
-  owner: {
-    id: string
-  }
+  owner: string | undefined
+}
+
+type UnwrappedSubname = BaseSubname & {
+  fuses?: never
+  expiryDate?: never
+  pccExpired?: never
+  type: 'domain'
 }
 
+type WrappedSubname = BaseSubname & {
+  fuses: AllCurrentFuses
+  expiryDate: Date
+  pccExpired: boolean
+  type: 'wrappedDomain'
+}
+
+type Subname = WrappedSubname | UnwrappedSubname
+
 type Params = {
   name: string
   page?: number
@@ -90,6 +106,13 @@ const largeQuery = async (
           owner {
             id
           }
+          wrappedDomain {
+            fuses
+            expiryDate
+            owner {
+              id
+            }
+          }
         }
       }
     }
@@ -106,18 +129,44 @@ const largeQuery = async (
   }
   const response = await client.request(finalQuery, queryVars)
   const domain = response?.domain
-  const subdomains = domain.subdomains.map((subname: any) => {
-    const decrypted = decryptName(subname.name)
+  const subdomains = domain.subdomains.map(
+    ({ wrappedDomain, ...subname }: Domain) => {
+      const decrypted = decryptName(subname.name!)
 
-    return {
-      ...subname,
-      name: decrypted,
-      truncatedName: truncateFormat(decrypted),
-    }
-  })
+      const obj = {
+        ...subname,
+        labelName: subname.labelName || null,
+        labelhash: subname.labelhash || '',
+        name: decrypted,
+        truncatedName: truncateFormat(decrypted),
+        owner: subname.owner.id,
+        type: 'domain',
+      } as Subname
+
+      if (wrappedDomain) {
+        obj.type = 'wrappedDomain'
+        const expiryDateAsDate =
+          wrappedDomain.expiryDate && wrappedDomain.expiryDate !== '0'
+            ? new Date(parseInt(wrappedDomain.expiryDate) * 1000)
+            : undefined
+        // if a user's local time is out of sync with the blockchain, this could potentially
+        // be incorrect. the likelihood of that happening though is very low, and devs
+        // shouldn't be relying on this value for anything critical anyway.
+        const hasExpired = expiryDateAsDate && expiryDateAsDate < new Date()
+        obj.expiryDate = expiryDateAsDate
+        obj.fuses = decodeFuses(hasExpired ? 0 : wrappedDomain.fuses)
+        obj.pccExpired = hasExpired
+          ? checkPCCBurned(wrappedDomain.fuses)
+          : false
+        obj.owner = obj.pccExpired ? undefined : wrappedDomain.owner.id
+      }
+
+      return obj
+    },
+  )
 
   return {
-    subnames: subdomains,
+    subnames: subdomains as Subname[],
     subnameCount: domain.subdomainCount,
   }
 }

package/src/functions/getWrapperData.test.ts

@@ -59,7 +59,6 @@ describe('getWrapperData', () => {
     const result = await ensInstance.getWrapperData('wrapped.eth')
     expect(result).toBeTruthy()
     if (result) {
-      console.log(result.expiryDate)
       expect(result.expiryDate).toBeInstanceOf(Date)
       expect(Number.isNaN(result.expiryDate?.getTime())).toBe(false)
     }

package/src/functions/transferSubname.test.ts

@@ -17,10 +17,11 @@ afterAll(async () => {
   await revert()
 })
 
+beforeEach(async () => {
+  await revert()
+})
+
 describe('transferSubname', () => {
-  beforeEach(async () => {
-    await revert()
-  })
   it('should allow transferring a subname on the registry', async () => {
     const tx = await ensInstance.transferSubname('test.with-subnames.eth', {
       contract: 'registry',
@@ -34,22 +35,123 @@ describe('transferSubname', () => {
     const result = await registry.owner(namehash('test.with-subnames.eth'))
     expect(result).toBe(accounts[1])
   })
-  it('should allow transferring a subname on the nameWrapper', async () => {
-    const tx = await ensInstance.transferSubname(
-      'test.wrapped-with-subnames.eth',
-      {
-        contract: 'nameWrapper',
-        owner: accounts[1],
+
+  describe('wrapped name with PCC NOT burned', () => {
+    it('should NOT allow transferring a subname by name owner', async () => {
+      const nameWrapper = await ensInstance.contracts!.getNameWrapper()!
+      await expect(
+        ensInstance.transferSubname('test.wrapped-with-subnames.eth', {
+          contract: 'nameWrapper',
+          owner: accounts[1],
+          addressOrIndex: 2,
+        }),
+      ).rejects.toThrow()
+
+      const result = await nameWrapper.ownerOf(
+        namehash('test.wrapped-with-subnames.eth'),
+      )
+      expect(result).toBe(accounts[2])
+    })
+
+    it('should allow transferring a subname by parent owner', async () => {
+      const tx = await ensInstance.transferSubname(
+        'test.wrapped-with-subnames.eth',
+        {
+          contract: 'nameWrapper',
+          owner: accounts[1],
+          addressOrIndex: 1,
+        },
+      )
+      expect(tx).toBeTruthy()
+      await tx.wait()
+
+      const nameWrapper = await ensInstance.contracts!.getNameWrapper()!
+      const result = await nameWrapper.ownerOf(
+        namehash('test.wrapped-with-subnames.eth'),
+      )
+      expect(result).toBe(accounts[1])
+    })
+  })
+
+  describe('wrapped name with PCC burned', () => {
+    beforeEach(async () => {
+      const tx0 = await ensInstance.setFuses('wrapped-with-subnames.eth', {
+        named: ['CANNOT_UNWRAP'],
         addressOrIndex: 1,
-      },
-    )
-    expect(tx).toBeTruthy()
-    await tx.wait()
+      })
+      expect(tx0).toBeTruthy()
+      await tx0.wait()
+    })
 
-    const nameWrapper = await ensInstance.contracts!.getNameWrapper()!
-    const result = await nameWrapper.ownerOf(
-      namehash('test.wrapped-with-subnames.eth'),
-    )
-    expect(result).toBe(accounts[1])
+    it('should NOT allow transferring a subname by name owner', async () => {
+      const nameWrapper = await ensInstance.contracts!.getNameWrapper()!
+
+      const tx1 = await ensInstance.setChildFuses(
+        'test.wrapped-with-subnames.eth',
+        {
+          fuses: {
+            parent: {
+              named: ['PARENT_CANNOT_CONTROL'],
+            },
+          },
+          addressOrIndex: 1,
+        },
+      )
+      expect(tx1).toBeTruthy()
+      await tx1.wait()
+
+      const checkOwner = await nameWrapper.ownerOf(
+        namehash('test.wrapped-with-subnames.eth'),
+      )
+      expect(checkOwner).toBe(accounts[2])
+
+      await expect(
+        ensInstance.transferSubname('test.wrapped-with-subnames.eth', {
+          contract: 'nameWrapper',
+          owner: accounts[1],
+          addressOrIndex: 2,
+        }),
+      ).rejects.toThrow()
+      const result = await nameWrapper.ownerOf(
+        namehash('test.wrapped-with-subnames.eth'),
+      )
+      expect(result).toBe(accounts[2])
+    })
+
+    it('should NOT allow transferring a subname by parent owner', async () => {
+      const nameWrapper = await ensInstance.contracts!.getNameWrapper()!
+
+      const tx1 = await ensInstance.setChildFuses(
+        'test.wrapped-with-subnames.eth',
+        {
+          fuses: {
+            parent: {
+              named: ['PARENT_CANNOT_CONTROL'],
+            },
+          },
+          addressOrIndex: 1,
+        },
+      )
+      expect(tx1).toBeTruthy()
+      await tx1.wait()
+
+      const checkOwner = await nameWrapper.ownerOf(
+        namehash('test.wrapped-with-subnames.eth'),
+      )
+      expect(checkOwner).toBe(accounts[2])
+
+      await expect(
+        ensInstance.transferSubname('test.wrapped-with-subnames.eth', {
+          contract: 'nameWrapper',
+          owner: accounts[1],
+          addressOrIndex: 1,
+        }),
+      ).rejects.toThrow()
+
+      const result = await nameWrapper.ownerOf(
+        namehash('test.wrapped-with-subnames.eth'),
+      )
+      expect(result).toBe(accounts[2])
+    })
   })
 })

package/src/functions/transferSubname.ts

@@ -1,7 +1,7 @@
 import { keccak256 as solidityKeccak256 } from '@ethersproject/solidity'
 import { ENSArgs } from '..'
 import { namehash } from '../utils/normalise'
-import { Expiry, makeExpiry } from '../utils/wrapper'
+import { expiryToBigNumber, Expiry } from '../utils/wrapper'
 
 type BaseArgs = {
   owner: string
@@ -17,11 +17,7 @@ type NameWrapperArgs = {
 type Args = BaseArgs | NameWrapperArgs
 
 export default async function (
-  {
-    contracts,
-    signer,
-    getExpiry,
-  }: ENSArgs<'contracts' | 'signer' | 'getExpiry'>,
+  { contracts, signer }: ENSArgs<'contracts' | 'signer'>,
   name: string,
   { contract, owner, resolverAddress, ...wrapperArgs }: Args,
 ) {
@@ -42,10 +38,9 @@ export default async function (
     }
     case 'nameWrapper': {
       const nameWrapper = (await contracts!.getNameWrapper()!).connect(signer)
-      const expiry = await makeExpiry(
-        { getExpiry },
-        labels.join('.'),
-        'expiry' in wrapperArgs ? wrapperArgs.expiry : undefined,
+      const expiry = expiryToBigNumber(
+        (wrapperArgs as NameWrapperArgs).expiry,
+        0,
       )
 
       return nameWrapper.populateTransaction.setSubnodeOwner(

package/src/index.ts

@@ -625,7 +625,7 @@ export class ENS {
 
   public transferSubname = this.generateWriteFunction<
     FunctionTypes['transferSubname']
-  >('transferSubname', ['contracts', 'getExpiry'])
+  >('transferSubname', ['contracts'])
 
   public commitName = this.generateWriteFunction<FunctionTypes['commitName']>(
     'commitName',

package/src/utils/consts.ts

@@ -1,2 +1,2 @@
 export const EMPTY_ADDRESS = '0x0000000000000000000000000000000000000000'
-export const MAX_INT_64 = 2n ** 64n - 1n
+export const MAX_INT_64 = BigInt('18446744073709551615')

package/src/utils/fuses.ts

@@ -352,6 +352,9 @@ export const decodeFuses = (fuses: number) => {
   }
 }
 
+export const checkPCCBurned = (fuses: number) =>
+  (fuses & PARENT_CANNOT_CONTROL) === PARENT_CANNOT_CONTROL
+
 export type AllCurrentFuses = ReturnType<typeof decodeFuses>
 
 export default fullFuseEnum

package/src/utils/registry.ts

@@ -0,0 +1,14 @@
+import { ENSArgs } from '../index'
+import { namehash } from './normalise'
+
+export const makeResolver = async (
+  { contracts }: ENSArgs<'contracts'>,
+  name: string,
+  resolver?: string,
+) => {
+  if (resolver) return resolver
+  const registry = await contracts!.getRegistry()
+  const node = namehash(name)
+  const _resolver = await registry.resolver(node)
+  return _resolver
+}

package/src/utils/wrapper.ts

@@ -6,20 +6,23 @@ export type Expiry = string | number | Date | BigNumber
 
 export const MAX_EXPIRY = BigNumber.from(2).pow(64).sub(1)
 
+export const expiryToBigNumber = (expiry?: Expiry, defaultValue = 0) => {
+  if (!expiry) return BigNumber.from(defaultValue)
+  if (expiry instanceof Date) {
+    return BigNumber.from(expiry.getTime() / 1000)
+  }
+  if (expiry instanceof BigNumber) {
+    return expiry
+  }
+  return BigNumber.from(expiry)
+}
+
 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 (expiry) return expiryToBigNumber(expiry)
   if (name.endsWith('.eth')) {
     const expResponse = await getExpiry(name)
     if (!expResponse?.expiry)