@ensdomains/ensjs 3.0.0-alpha.6 → 3.0.0-alpha.61

package/src/functions/supportsTLD.test.ts

@@ -0,0 +1,45 @@
+import { ENS } from '..'
+import setup from '../tests/setup'
+
+let ensInstance: ENS
+let revert: Awaited<ReturnType<typeof setup>>['revert']
+
+beforeAll(async () => {
+  ;({ ensInstance, revert } = await setup())
+})
+
+afterAll(async () => {
+  await revert()
+})
+
+describe('supportsTLD', () => {
+  it('should return true for .eth tld', async () => {
+    const result = await ensInstance.supportsTLD('eth')
+    expect(result).toBeTruthy()
+  })
+
+  it('should return true for .xyz tld', async () => {
+    const result = await ensInstance.supportsTLD('xyz')
+    expect(result).toBeTruthy()
+  })
+
+  it('should return false for .com tld', async () => {
+    const result = await ensInstance.supportsTLD('com')
+    expect(result).toBeFalsy()
+  })
+
+  it('should return true for .eth name', async () => {
+    const result = await ensInstance.supportsTLD('test123.eth')
+    expect(result).toBeTruthy()
+  })
+
+  it('should return true for .xyz name', async () => {
+    const result = await ensInstance.supportsTLD('test123.xyz')
+    expect(result).toBeTruthy()
+  })
+
+  it('should return false for .com name', async () => {
+    const result = await ensInstance.supportsTLD('test123.com')
+    expect(result).toBeFalsy()
+  })
+})

package/src/functions/supportsTLD.ts

@@ -0,0 +1,38 @@
+import { DNSRegistrar__factory } from '../generated/factories/DNSRegistrar__factory'
+import { ENSArgs } from '..'
+
+/*
+ * 0x2f435428 -> interfaceId for latest IDNSRegistrar
+ * 0x17d8f49b, 0x1aa2e641 -> interfaceId for claims method of older DNSRegistrar
+ * */
+const DNSSEC_CLAIM_INTERFACE_IDS = ['0x2f435428', '0x17d8f49b', '0x1aa2e641']
+
+export default async function (
+  { getOwner, provider }: ENSArgs<'getOwner' | 'provider'>,
+  name: string,
+): Promise<boolean> {
+  try {
+    const labels = name.split('.')
+    const tld = labels[labels.length - 1]
+
+    if (tld === 'eth') return true
+
+    const tldOwner = await getOwner(tld, 'registry')
+    if (!tldOwner?.owner) return false
+
+    const dnsRegistrar = DNSRegistrar__factory.connect(
+      tldOwner.owner,
+      provider!,
+    )
+
+    const supports = await Promise.all(
+      DNSSEC_CLAIM_INTERFACE_IDS.map((interfaceId) =>
+        dnsRegistrar.supportsInterface(interfaceId),
+      ),
+    )
+
+    return supports.some((s) => !!s)
+  } catch {
+    return false
+  }
+}

package/src/functions/transferController.ts

@@ -0,0 +1,29 @@
+import { keccak256 as solidityKeccak256 } from '@ethersproject/solidity'
+
+import { ENSArgs } from '..'
+
+export default async function (
+  { contracts, signer }: ENSArgs<'contracts' | 'signer'>,
+  name: string,
+  {
+    newOwner,
+    isOwner,
+  }: {
+    newOwner: string
+    isOwner: boolean
+  },
+) {
+  const baseRegistrar = (await contracts?.getBaseRegistrar())!.connect(signer)
+  const registry = (await contracts?.getRegistry())!.connect(signer)
+  const labels = name.split('.')
+  if (isOwner) {
+    return registry.populateTransaction.setOwner(
+      solidityKeccak256(['string'], [labels[0]]),
+      newOwner,
+    )
+  }
+  return baseRegistrar.populateTransaction.reclaim(
+    solidityKeccak256(['string'], [labels[0]]),
+    newOwner,
+  )
+}

package/src/functions/transferName.test.ts

@@ -3,13 +3,13 @@ import { ENS } from '..'
 import setup from '../tests/setup'
 import { namehash } from '../utils/normalise'
 
-let ENSInstance: ENS
+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())
+  ;({ ensInstance, revert, provider } = await setup())
   accounts = await provider.listAccounts()
 })
 
@@ -22,58 +22,44 @@ describe('transferName', () => {
     await revert()
   })
   it('should allow a transfer on the registrar', async () => {
-    const tx = await ENSInstance.transferName('parthtejpal.eth', {
+    const tx = await ensInstance.transferName('test123.eth', {
       contract: 'baseRegistrar',
-      newOwner: accounts[1],
-      addressOrIndex: 0,
+      newOwner: accounts[2],
+      addressOrIndex: 1,
     })
     expect(tx).toBeTruthy()
     await tx.wait()
 
-    const baseRegistrar = await ENSInstance.contracts!.getBaseRegistrar()!
+    const baseRegistrar = await ensInstance.contracts!.getBaseRegistrar()!
     const result = await baseRegistrar.ownerOf(
-      utils.solidityKeccak256(['string'], ['parthtejpal']),
+      utils.solidityKeccak256(['string'], ['test123']),
     )
-    expect(result).toBe(accounts[1])
+    expect(result).toBe(accounts[2])
   })
   it('should allow a transfer on the namewrapper', async () => {
-    const wrapNameTx = await ENSInstance.wrapName('parthtejpal.eth', {
-      wrappedOwner: accounts[0],
-    })
-    await wrapNameTx.wait()
-    const tx = await ENSInstance.transferName('parthtejpal.eth', {
-      newOwner: accounts[1],
+    const tx = await ensInstance.transferName('wrapped.eth', {
+      newOwner: accounts[2],
       contract: 'nameWrapper',
-      addressOrIndex: 0,
+      addressOrIndex: 1,
     })
     expect(tx).toBeTruthy()
     await tx.wait()
 
-    const nameWrapper = await ENSInstance.contracts!.getNameWrapper()!
-    const result = await nameWrapper.ownerOf(namehash('parthtejpal.eth'))
-    expect(result).toBe(accounts[1])
+    const nameWrapper = await ensInstance.contracts!.getNameWrapper()!
+    const result = await nameWrapper.ownerOf(namehash('wrapped.eth'))
+    expect(result).toBe(accounts[2])
   })
   it('should allow a transfer on the registry', async () => {
-    const createSubnameTx = await ENSInstance.createSubname(
-      'test.parthtejpal.eth',
-      {
-        contract: 'registry',
-        owner: accounts[0],
-        addressOrIndex: accounts[0],
-      },
-    )
-    await createSubnameTx.wait()
-
-    const tx = await ENSInstance.transferName('test.parthtejpal.eth', {
+    const tx = await ensInstance.transferName('test.with-subnames.eth', {
       newOwner: accounts[1],
       contract: 'registry',
-      addressOrIndex: accounts[0],
+      addressOrIndex: accounts[2],
     })
     expect(tx).toBeTruthy()
     await tx.wait()
 
-    const registry = await ENSInstance.contracts!.getRegistry()!
-    const result = await registry.owner(namehash('test.parthtejpal.eth'))
+    const registry = await ensInstance.contracts!.getRegistry()!
+    const result = await registry.owner(namehash('test.with-subnames.eth'))
     expect(result).toBe(accounts[1])
   })
 })

package/src/functions/transferName.ts

@@ -1,4 +1,4 @@
-import { ethers } from 'ethers'
+import { keccak256 as solidityKeccak256 } from '@ethersproject/solidity'
 import { ENSArgs } from '..'
 import { namehash } from '../utils/normalise'
 
@@ -8,9 +8,11 @@ export default async function (
   {
     newOwner,
     contract,
+    reclaim,
   }: {
     newOwner: string
     contract: 'registry' | 'nameWrapper' | 'baseRegistrar'
+    reclaim?: boolean
   },
 ) {
   const address = await signer.getAddress()
@@ -28,13 +30,16 @@ export default async function (
       if (labels.length > 2 || labels[labels.length - 1] !== 'eth') {
         throw new Error('Invalid name for baseRegistrar')
       }
+      const tokenId = solidityKeccak256(['string'], [labels[0]])
+
+      // reclaim if sending manager on unwrapped name
+      if (reclaim) {
+        return baseRegistrar.populateTransaction.reclaim(tokenId, newOwner)
+      }
+
       return baseRegistrar.populateTransaction[
         'safeTransferFrom(address,address,uint256)'
-      ](
-        address,
-        newOwner,
-        ethers.utils.solidityKeccak256(['string'], [labels[0]]),
-      )
+      ](address, newOwner, tokenId)
     }
     case 'nameWrapper': {
       const nameWrapper = (await contracts?.getNameWrapper())!.connect(signer)

package/src/functions/transferSubname.test.ts

@@ -3,13 +3,13 @@ import { ENS } from '..'
 import setup from '../tests/setup'
 import { namehash } from '../utils/normalise'
 
-let ENSInstance: ENS
+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())
+  ;({ ensInstance, revert, provider } = await setup())
   accounts = await provider.listAccounts()
 })
 
@@ -17,58 +17,141 @@ 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 createSubnameTx = await ENSInstance.createSubname(
-      'test.parthtejpal.eth',
-      {
-        contract: 'registry',
-        owner: accounts[0],
-        addressOrIndex: 0,
-      },
-    )
-    await createSubnameTx.wait()
-
-    const tx = await ENSInstance.transferSubname('test.parthtejpal.eth', {
+    const tx = await ensInstance.transferSubname('test.with-subnames.eth', {
       contract: 'registry',
-      address: accounts[1],
-      addressOrIndex: 0,
+      owner: accounts[1],
+      addressOrIndex: 1,
     })
     expect(tx).toBeTruthy()
     await tx.wait()
 
-    const registry = await ENSInstance.contracts!.getRegistry()!
-    const result = await registry.owner(namehash('test.parthtejpal.eth'))
+    const registry = await ensInstance.contracts!.getRegistry()!
+    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 wrapNameTx = await ENSInstance.wrapName('parthtejpal.eth', {
-      wrappedOwner: accounts[0],
+
+  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])
     })
-    await wrapNameTx.wait()
-    const createSubnameTx = await ENSInstance.createSubname(
-      'test.parthtejpal.eth',
-      {
-        contract: 'nameWrapper',
-        owner: accounts[0],
-        addressOrIndex: 0,
-      },
-    )
-    await createSubnameTx.wait()
-
-    const tx = await ENSInstance.transferSubname('test.parthtejpal.eth', {
-      contract: 'nameWrapper',
-      address: accounts[1],
-      addressOrIndex: 0,
+
+    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])
     })
-    expect(tx).toBeTruthy()
-    await tx.wait()
+  })
 
-    const nameWrapper = await ENSInstance.contracts!.getNameWrapper()!
-    const result = await nameWrapper.ownerOf(namehash('test.parthtejpal.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(tx0).toBeTruthy()
+      await tx0.wait()
+    })
+
+    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,41 +1,54 @@
-import { ethers } from 'ethers'
+import { keccak256 as solidityKeccak256 } from '@ethersproject/solidity'
 import { ENSArgs } from '..'
 import { namehash } from '../utils/normalise'
+import { expiryToBigNumber, Expiry } from '../utils/wrapper'
+
+type BaseArgs = {
+  owner: string
+  resolverAddress?: string
+  contract: 'registry' | 'nameWrapper'
+}
+
+type NameWrapperArgs = {
+  contract: 'nameWrapper'
+  expiry?: Expiry
+} & BaseArgs
+
+type Args = BaseArgs | NameWrapperArgs
 
 export default async function (
   { contracts, signer }: ENSArgs<'contracts' | 'signer'>,
   name: string,
-  {
-    contract,
-    address,
-  }: {
-    contract: 'registry' | 'nameWrapper'
-    address: string
-  },
+  { contract, owner, resolverAddress, ...wrapperArgs }: Args,
 ) {
   const labels = name.split('.')
   const label = labels.shift() as string
-  const labelhash = ethers.utils.solidityKeccak256(['string'], [label])
+  const labelhash = solidityKeccak256(['string'], [label])
   const parentNodehash = namehash(labels.join('.'))
 
   switch (contract) {
     case 'registry': {
-      const registry = (await contracts?.getRegistry()!).connect(signer)
+      const registry = (await contracts!.getRegistry()!).connect(signer)
 
       return registry.populateTransaction.setSubnodeOwner(
         parentNodehash,
         labelhash,
-        address,
+        owner,
       )
     }
     case 'nameWrapper': {
-      const nameWrapper = (await contracts?.getNameWrapper()!).connect(signer)
+      const nameWrapper = (await contracts!.getNameWrapper()!).connect(signer)
+      const expiry = expiryToBigNumber(
+        (wrapperArgs as NameWrapperArgs).expiry,
+        0,
+      )
 
       return nameWrapper.populateTransaction.setSubnodeOwner(
         parentNodehash,
         label,
-        address,
+        owner,
         '0',
+        expiry,
       )
     }
     default: {

package/src/functions/types.ts

@@ -0,0 +1,100 @@
+import type batch from './batch'
+import type {
+  multicallWrapper,
+  resolverMulticallWrapper,
+  universalWrapper,
+} from './batchWrappers'
+import type commitName from './commitName'
+import type createSubname from './createSubname'
+import type deleteSubname from './deleteSubname'
+import type getAvailable from './getAvailable'
+import type getDecryptedName from './getDecryptedName'
+import type getDNSOwner from './getDNSOwner'
+import type getExpiry from './getExpiry'
+import type { getHistory } from './getHistory'
+import type getName from './getName'
+import type getNames from './getNames'
+import type getOwner from './getOwner'
+import type getPrice from './getPrice'
+import type getProfile from './getProfile'
+import type getResolver from './getResolver'
+import type {
+  getABI,
+  getAddr,
+  getContentHash,
+  getText,
+  _getABI,
+  _getAddr,
+  _getContentHash,
+  _getText,
+} from './getSpecificRecord'
+import type getSubnames from './getSubnames'
+import type getWrapperData from './getWrapperData'
+import type importDNSSECName from './importDNSSECName'
+import type registerName from './registerName'
+import type {
+  // eslint-disable-next-line import/no-named-default
+  default as renewNames,
+  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'
+import type setResolver from './setResolver'
+import type supportsTLD from './supportsTLD'
+import type transferController from './transferController'
+import type transferName from './transferName'
+import type transferSubname from './transferSubname'
+import type unwrapName from './unwrapName'
+import type wrapName from './wrapName'
+
+type Function = {
+  batch: typeof batch
+  multicallWrapper: typeof multicallWrapper
+  resolverMulticallWrapper: typeof resolverMulticallWrapper
+  universalWrapper: typeof universalWrapper
+  setFuses: typeof setFuses
+  setChildFuses: typeof setChildFuses
+  commitName: typeof commitName
+  createSubname: typeof createSubname
+  deleteSubname: typeof deleteSubname
+  getAvailable: typeof getAvailable
+  getDecryptedName: typeof getDecryptedName
+  getDNSOwner: typeof getDNSOwner
+  getExpiry: typeof getExpiry
+  getHistory: typeof getHistory
+  getName: typeof getName
+  getNames: typeof getNames
+  getOwner: typeof getOwner
+  getPrice: typeof getPrice
+  getProfile: typeof getProfile
+  getResolver: typeof getResolver
+  getAddr: typeof getAddr
+  getContentHash: typeof getContentHash
+  getText: typeof getText
+  getABI: typeof getABI
+  _getAddr: typeof _getAddr
+  _getContentHash: typeof _getContentHash
+  _getText: typeof _getText
+  _getABI: typeof _getABI
+  getSubnames: typeof getSubnames
+  getWrapperData: typeof getWrapperData
+  importDNSSECName: typeof importDNSSECName
+  registerName: typeof registerName
+  renewNames: typeof renewNames
+  extendWrappedName: typeof extendWrappedName
+  setName: typeof setName
+  setRecord: typeof setRecord
+  setRecords: typeof setRecords
+  setResolver: typeof setResolver
+  supportsTLD: typeof supportsTLD
+  transferController: typeof transferController
+  transferName: typeof transferName
+  transferSubname: typeof transferSubname
+  unwrapName: typeof unwrapName
+  wrapName: typeof wrapName
+}
+
+export default Function