@ensdomains/ensjs 3.0.0-alpha.46 → 3.0.0-alpha.48

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/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)