@ensdomains/ensjs 3.0.0-alpha.5 → 3.0.0-alpha.51

package/src/functions/setRecord.ts

@@ -0,0 +1,64 @@
+import { ENSArgs } from '..'
+import { namehash } from '../utils/normalise'
+import { generateSingleRecordCall, RecordInput } from '../utils/recordHelpers'
+
+type BaseInput = {
+  resolverAddress?: string
+}
+
+type ContentHashInput = {
+  record: RecordInput<'contentHash'>
+  type: 'contentHash'
+}
+
+type AddrOrTextInput = {
+  record: RecordInput<'addr' | 'text'>
+  type: 'addr' | 'text'
+}
+
+type ABIInput = {
+  record: RecordInput<'abi'>
+  type: 'abi'
+}
+
+export default async function (
+  {
+    contracts,
+    provider,
+    getResolver,
+    signer,
+  }: ENSArgs<'contracts' | 'provider' | 'getResolver' | 'signer'>,
+  name: string,
+  {
+    record,
+    type,
+    resolverAddress,
+  }: BaseInput & (ContentHashInput | AddrOrTextInput | ABIInput),
+) {
+  if (!name.includes('.')) {
+    throw new Error('Input is not an ENS name')
+  }
+
+  let resolverToUse: string
+  if (resolverAddress) {
+    resolverToUse = resolverAddress
+  } else {
+    resolverToUse = await getResolver(name)
+  }
+
+  if (!resolverToUse) {
+    throw new Error('No resolver found for input address')
+  }
+
+  const resolver = (
+    await contracts?.getPublicResolver(provider, resolverToUse)
+  )?.connect(signer)!
+  const hash = namehash(name)
+
+  const call = generateSingleRecordCall(hash, resolver, type)(record)
+
+  return {
+    to: resolver.address,
+    data: call,
+  }
+}

package/src/functions/setRecords.test.ts

@@ -1,13 +1,34 @@
+import { toUtf8String } from 'ethers/lib/utils'
 import { ENS } from '..'
 import setup from '../tests/setup'
 import { hexEncodeName } from '../utils/hexEncodedName'
 import { namehash } from '../utils/normalise'
 
-let ENSInstance: ENS
+const dummyABI = [
+  {
+    type: 'function',
+    name: 'supportsInterface',
+    constant: true,
+    stateMutability: 'view',
+    payable: false,
+    inputs: [
+      {
+        type: 'bytes4',
+      },
+    ],
+    outputs: [
+      {
+        type: 'bool',
+      },
+    ],
+  },
+]
+
+let ensInstance: ENS
 let revert: Awaited<ReturnType<typeof setup>>['revert']
 
 beforeAll(async () => {
-  ;({ ENSInstance, revert } = await setup())
+  ;({ ensInstance, revert } = await setup())
 })
 
 afterAll(async () => {
@@ -16,36 +37,43 @@ afterAll(async () => {
 
 describe('setRecords', () => {
   it('should return a transaction to the resolver and set successfully', async () => {
-    const tx = await ENSInstance.setRecords('parthtejpal.eth', {
+    const tx = await ensInstance.setRecords('test123.eth', {
       records: {
         coinTypes: [
-          { key: 'ETC', value: '0x42D63ae25990889E35F215bC95884039Ba354115' },
+          {
+            key: 'ETC_LEGACY',
+            value: '0x42D63ae25990889E35F215bC95884039Ba354115',
+          },
         ],
         texts: [{ key: 'foo', value: 'bar' }],
+        abi: {
+          data: dummyABI,
+        },
       },
+      addressOrIndex: 1,
     })
     expect(tx).toBeTruthy()
     await tx.wait()
 
     const universalResolver =
-      await ENSInstance.contracts!.getUniversalResolver()!
-    const publicResolver = await ENSInstance.contracts!.getPublicResolver()!
-    const encodedText = await universalResolver.resolve(
-      hexEncodeName('parthtejpal.eth'),
-      publicResolver.interface.encodeFunctionData('text(bytes32,string)', [
-        namehash('parthtejpal.eth'),
+      await ensInstance.contracts!.getUniversalResolver()!
+    const publicResolver = await ensInstance.contracts!.getPublicResolver()!
+    const encodedText = await universalResolver['resolve(bytes,bytes)'](
+      hexEncodeName('test123.eth'),
+      publicResolver.interface.encodeFunctionData('text', [
+        namehash('test123.eth'),
         'foo',
       ]),
     )
-    const encodedAddr = await universalResolver.resolve(
-      hexEncodeName('parthtejpal.eth'),
+    const encodedAddr = await universalResolver['resolve(bytes,bytes)'](
+      hexEncodeName('test123.eth'),
       publicResolver.interface.encodeFunctionData('addr(bytes32,uint256)', [
-        namehash('parthtejpal.eth'),
+        namehash('test123.eth'),
         '61',
       ]),
     )
     const [resultText] = publicResolver.interface.decodeFunctionResult(
-      'text(bytes32,string)',
+      'text',
       encodedText[0],
     )
     const [resultAddr] = publicResolver.interface.decodeFunctionResult(
@@ -56,5 +84,17 @@ describe('setRecords', () => {
     expect(resultAddr).toBe(
       '0x42D63ae25990889E35F215bC95884039Ba354115'.toLowerCase(),
     )
+
+    const encodedABI = await universalResolver['resolve(bytes,bytes)'](
+      hexEncodeName('test123.eth'),
+      publicResolver.interface.encodeFunctionData('ABI', [
+        namehash('test123.eth'),
+        '0x01',
+      ]),
+    )
+    const [contentType, resultABI] =
+      publicResolver.interface.decodeFunctionResult('ABI', encodedABI[0])
+    expect(contentType.toNumber()).toBe(1)
+    expect(toUtf8String(resultABI)).toBe(JSON.stringify(dummyABI))
   })
 })

package/src/functions/setRecords.ts

@@ -35,10 +35,10 @@ export default async function (
 
   const resolver = (
     await contracts?.getPublicResolver(provider, resolverToUse)
-  )?.connect(signer)
+  )?.connect(signer)!
   const hash = namehash(name)
 
   const calls: string[] = generateRecordCallArray(hash, records, resolver!)
 
-  return resolver?.multicall(calls)
+  return resolver.populateTransaction.multicall(calls)
 }

package/src/functions/setResolver.test.ts

@@ -1,14 +1,12 @@
-import { ethers } from 'ethers'
 import { ENS } from '..'
 import setup from '../tests/setup'
 import { hexEncodeName } from '../utils/hexEncodedName'
 
-let ENSInstance: ENS
+let ensInstance: ENS
 let revert: Awaited<ReturnType<typeof setup>>['revert']
-let provider: ethers.providers.JsonRpcProvider
 
 beforeAll(async () => {
-  ;({ ENSInstance, revert, provider } = await setup())
+  ;({ ensInstance, revert } = await setup())
 })
 
 afterAll(async () => {
@@ -20,37 +18,34 @@ describe('setResolver', () => {
     await revert()
   })
   it('should return a transaction to the registry and set successfully', async () => {
-    const tx = await ENSInstance.setResolver('parthtejpal.eth', {
+    const tx = await ensInstance.setResolver('test123.eth', {
       contract: 'registry',
       resolver: '0xAEfF4f4d8e2cB51854BEa2244B3C5Fb36b41C7fC',
+      addressOrIndex: 1,
     })
     expect(tx).toBeTruthy()
     await tx.wait()
 
     const universalResolver =
-      await ENSInstance.contracts!.getUniversalResolver()!
+      await ensInstance.contracts!.getUniversalResolver()!
     const [result] = await universalResolver.findResolver(
-      hexEncodeName('parthtejpal.eth'),
+      hexEncodeName('test123.eth'),
     )
     expect(result).toBe('0xAEfF4f4d8e2cB51854BEa2244B3C5Fb36b41C7fC')
   })
   it('should return a transaction to the namewrapper and set successfully', async () => {
-    const accounts = await provider.listAccounts()
-    const wrapNameTx = await ENSInstance.wrapName('parthtejpal.eth', {
-      wrappedOwner: accounts[0],
-    })
-    await wrapNameTx.wait()
-    const tx = await ENSInstance.setResolver('parthtejpal.eth', {
+    const tx = await ensInstance.setResolver('wrapped.eth', {
       contract: 'nameWrapper',
       resolver: '0xAEfF4f4d8e2cB51854BEa2244B3C5Fb36b41C7fC',
+      addressOrIndex: 1,
     })
     expect(tx).toBeTruthy()
     await tx.wait()
 
     const universalResolver =
-      await ENSInstance.contracts!.getUniversalResolver()!
+      await ensInstance.contracts!.getUniversalResolver()!
     const [result] = await universalResolver.findResolver(
-      hexEncodeName('parthtejpal.eth'),
+      hexEncodeName('wrapped.eth'),
     )
     expect(result).toBe('0xAEfF4f4d8e2cB51854BEa2244B3C5Fb36b41C7fC')
   })

package/src/functions/setResolver.ts

@@ -13,17 +13,20 @@ export default async function (
   },
 ) {
   if (!resolver) {
-    resolver = (await contracts?.getPublicResolver()!).address
+    resolver = (await contracts!.getPublicResolver()!).address
   }
 
   switch (contract) {
     case 'registry': {
       const registry = (await contracts?.getRegistry())!.connect(signer)
-      return registry.setResolver(namehash(name), resolver)
+      return registry.populateTransaction.setResolver(namehash(name), resolver)
     }
     case 'nameWrapper': {
       const nameWrapper = (await contracts?.getNameWrapper())!.connect(signer)
-      return nameWrapper.setResolver(namehash(name), resolver)
+      return nameWrapper.populateTransaction.setResolver(
+        namehash(name),
+        resolver,
+      )
     }
     default: {
       throw new Error(`Unknown contract: ${contract}`)

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()
@@ -18,7 +20,7 @@ export default async function (
   switch (contract) {
     case 'registry': {
       const registry = (await contracts?.getRegistry())!.connect(signer)
-      return registry.setOwner(namehash(name), newOwner)
+      return registry.populateTransaction.setOwner(namehash(name), newOwner)
     }
     case 'baseRegistrar': {
       const baseRegistrar = (await contracts?.getBaseRegistrar())!.connect(
@@ -28,15 +30,20 @@ export default async function (
       if (labels.length > 2 || labels[labels.length - 1] !== 'eth') {
         throw new Error('Invalid name for baseRegistrar')
       }
-      return baseRegistrar['safeTransferFrom(address,address,uint256)'](
-        address,
-        newOwner,
-        ethers.utils.solidityKeccak256(['string'], [labels[0]]),
-      )
+      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, tokenId)
     }
     case 'nameWrapper': {
       const nameWrapper = (await contracts?.getNameWrapper())!.connect(signer)
-      return nameWrapper.safeTransferFrom(
+      return nameWrapper.populateTransaction.safeTransferFrom(
         address,
         newOwner,
         namehash(name),