@ensdomains/ensjs 3.0.0-alpha.2 → 3.0.0-alpha.20

package/src/functions/getSpecificRecord.ts

@@ -15,11 +15,17 @@ export const _getContentHash = {
     }
   },
   decode: async ({ contracts }: ENSArgs<'contracts'>, data: string) => {
+    let response: any
     const publicResolver = await contracts?.getPublicResolver()!
-    const [response] = publicResolver.interface.decodeFunctionResult(
-      'contenthash',
-      data,
-    )
+    try {
+      ;[response] = publicResolver.interface.decodeFunctionResult(
+        'contenthash',
+        data,
+      )
+    } catch {
+      return
+    }
+
     if (!response) {
       return
     }
@@ -45,7 +51,7 @@ export const getContentHash = {
     name: string,
   ) => {
     const prData = await _getContentHash.raw({ contracts }, name)
-    return await universalWrapper.raw(name, prData.data)
+    return universalWrapper.raw(name, prData.data)
   },
   decode: async (
     { contracts, universalWrapper }: ENSArgs<'contracts' | 'universalWrapper'>,
@@ -53,7 +59,7 @@ export const getContentHash = {
   ) => {
     const urData = await universalWrapper.decode(data)
     if (!urData) return
-    return await _getContentHash.decode({ contracts }, urData.data)
+    return _getContentHash.decode({ contracts }, urData.data)
   },
 }
 
@@ -92,7 +98,7 @@ export const getText = {
     key: string,
   ) => {
     const prData = await _getText.raw({ contracts }, name, key)
-    return await universalWrapper.raw(name, prData.data)
+    return universalWrapper.raw(name, prData.data)
   },
   decode: async (
     { contracts, universalWrapper }: ENSArgs<'contracts' | 'universalWrapper'>,
@@ -100,7 +106,7 @@ export const getText = {
   ) => {
     const urData = await universalWrapper.decode(data)
     if (!urData) return
-    return await _getText.decode({ contracts }, urData.data)
+    return _getText.decode({ contracts }, urData.data)
   },
 }
 
@@ -136,7 +142,7 @@ export const _getAddr = {
       }
     }
     const formatter =
-      typeof coinType === 'string' && isNaN(parseInt(coinType))
+      typeof coinType === 'string' && Number.isNaN(parseInt(coinType))
         ? formatsByName[coinType]
         : formatsByCoinType[
             typeof coinType === 'number' ? coinType : parseInt(coinType)
@@ -168,7 +174,7 @@ export const _getAddr = {
 
     const publicResolver = await contracts?.getPublicResolver()!
     const formatter =
-      typeof coinType === 'string' && isNaN(parseInt(coinType))
+      typeof coinType === 'string' && Number.isNaN(parseInt(coinType))
         ? formatsByName[coinType]
         : formatsByCoinType[
             typeof coinType === 'number' ? coinType : parseInt(coinType)
@@ -215,7 +221,7 @@ export const getAddr = {
     coinType?: string | number,
   ) => {
     const prData = await _getAddr.raw({ contracts }, name, coinType)
-    return await universalWrapper.raw(name, prData.data)
+    return universalWrapper.raw(name, prData.data)
   },
   decode: async (
     { contracts, universalWrapper }: ENSArgs<'contracts' | 'universalWrapper'>,
@@ -225,141 +231,6 @@ export const getAddr = {
   ) => {
     const urData = await universalWrapper.decode(data)
     if (!urData) return
-    return await _getAddr.decode({ contracts }, urData.data, _name, coinType)
+    return _getAddr.decode({ contracts }, urData.data, _name, coinType)
   },
 }
-
-// export async function getAddr(
-//   { contracts }: ENSArgs<'contracts'>,
-//   name: string,
-//   coinType?: string | number,
-// ) {
-//   if (!coinType) {
-//     coinType = 60
-//   }
-
-//   const universalResolver = await contracts?.getUniversalResolver()
-//   const publicResolver = await contracts?.getPublicResolver()
-//   const formatter =
-//     typeof coinType === 'string'
-//       ? formatsByName[coinType]
-//       : formatsByCoinType[coinType]
-
-//   if (!formatter) {
-//     throw new Error(`Coin type ${coinType} is not supported`)
-//   }
-
-//   const data = publicResolver?.interface.encodeFunctionData(
-//     'addr(bytes32,uint256)',
-//     [ethers.utils.namehash(name), formatter.coinType],
-//   )
-//   const result = await universalResolver?.resolve(hexEncodeName(name), data)
-
-//   const [encodedAddr] = ethers.utils.defaultAbiCoder.decode(
-//     ['bytes'],
-//     result['0'],
-//   )
-
-//   if (ethers.utils.hexStripZeros(encodedAddr) === '0x') {
-//     return
-//   }
-
-//   const decodedAddr = formatter.encoder(
-//     Buffer.from(encodedAddr.slice(2), 'hex'),
-//   )
-
-//   if (!decodedAddr) {
-//     return
-//   }
-
-//   return decodedAddr
-// }
-
-// export const getContentHash = {
-//   raw: async ({ contracts }: ENSArgs<'contracts'>, name: string) => {
-//     const universalResolver = await contracts?.getUniversalResolver()!
-//     const publicResolver = await contracts?.getPublicResolver()!
-//     const prData = publicResolver.interface.encodeFunctionData(
-//       'contenthash(bytes32)',
-//       [ethers.utils.namehash(name)],
-//     )
-//     const urData = universalResolver.interface.encodeFunctionData(
-//       'resolve(bytes,bytes)',
-//       [hexEncodeName(name), prData],
-//     )
-
-//     return {
-//       to: universalResolver.address,
-//       data: urData,
-//     }
-//   },
-//   decode: async ({ contracts }: ENSArgs<'contracts'>, data: string) => {
-//     const universalResolver = await contracts?.getUniversalResolver()!
-//     const publicResolver = await contracts?.getPublicResolver()!
-//     const response = universalResolver.interface.decodeFunctionResult(
-//       'resolve(bytes,bytes)',
-//       data,
-//     )
-
-//     if (!response || !response[1]) {
-//       return
-//     }
-
-//     const [encodedContentHash] = publicResolver.interface.decodeFunctionResult(
-//       'contenthash(bytes32)',
-//       response[0],
-//     )
-
-//     if (ethers.utils.hexStripZeros(encodedContentHash) === '0x') {
-//       return
-//     }
-
-//     return decodeContenthash(encodedContentHash)
-//   },
-// }
-
-// const getText = {
-//   raw: async (
-//     { contracts }: ENSArgs<'contracts'>,
-//     name: string,
-//     key: string,
-//   ) => {
-//     const universalResolver = await contracts?.getUniversalResolver()!
-//     const publicResolver = await contracts?.getPublicResolver()!
-//     const data = publicResolver.interface.encodeFunctionData(
-//       'text(bytes32,string)',
-//       [ethers.utils.namehash(name), key],
-//     )
-
-//     return {
-//       to: universalResolver.address,
-//       data: universalResolver.interface.encodeFunctionData(
-//         'resolve(bytes,bytes)',
-//         [hexEncodeName(name), data],
-//       ),
-//     }
-//   },
-//   decode: async ({ contracts }: ENSArgs<'contracts'>, data: string) => {
-//     const universalResolver = await contracts?.getUniversalResolver()!
-//     const publicResolver = await contracts?.getPublicResolver()!
-//     const response = universalResolver.interface.decodeFunctionResult(
-//       'resolve(bytes,bytes)',
-//       data,
-//     )
-
-//     if (!response || !response[1]) {
-//       return
-//     }
-
-//     const [decodedText] = publicResolver.interface.decodeFunctionResult(
-//       'text(bytes32,string)',
-//       response[0],
-//     )
-
-//     if (decodedText === '') {
-//       return
-//     }
-
-//     return decodedText
-//   },
-// }

package/src/functions/getSubnames.test.ts

@@ -0,0 +1,35 @@
+// import { ENS } from '..'
+// import setup from '../tests/setup'
+
+// let ensInstance: ENS
+
+// beforeAll(async () => {
+//   ;({ ensInstance } = await setup())
+// })
+
+// const testProperties = (obj: object, ...properties: string[]) =>
+//   properties.map((property) => expect(obj).toHaveProperty(property))
+
+describe('getSubnames', () => {
+  it.todo('should get the subnames for a name')
+  // it('should get the subnames for a name', async () => {
+  //   const result = await ensInstance.getSubnames({
+  //     name: 'with-profile.eth',
+  //   })
+  //   expect(result).toBeTruthy()
+  //   if (result) {
+  //     console.log(result)
+  //     expect(result.length).toBeGreaterThan(0)
+  //     testProperties(
+  //       result[0],
+  //       'id',
+  //       'labelName',
+  //       'labelhash',
+  //       'name',
+  //       'isMigrated',
+  //       'owner',
+  //       'truncatedName',
+  //     )
+  //   }
+  // })
+})

package/src/functions/getSubnames.ts

@@ -21,17 +21,17 @@ type Params = {
   pageSize?: number
   orderDirection?: 'asc' | 'desc'
   orderBy?: 'createdAt' | 'labelName'
-  lastSubnames: Array<any>
+  lastSubnames?: Array<any>
   isLargeQuery?: boolean
 }
 
 const largeQuery = async (
   { gqlInstance }: ENSArgs<'gqlInstance'>,
-  { name, page, pageSize = 10, orderDirection, orderBy, lastSubnames }: Params,
+  { name, pageSize = 10, orderDirection, orderBy, lastSubnames = [] }: Params,
 ) => {
-  const client = gqlInstance.client
+  const { client } = gqlInstance
 
-  let finalQuery = gqlInstance.gql`
+  const finalQuery = gqlInstance.gql`
     query getSubnames(
       $id: ID! 
       $first: Int
@@ -63,7 +63,7 @@ const largeQuery = async (
       }
     }
   `
-  let queryVars = {
+  const queryVars = {
     id: namehash(name),
     first: pageSize,
     lastCreatedAt: lastSubnames[lastSubnames.length - 1]?.createdAt,
@@ -90,7 +90,7 @@ const smallQuery = async (
   { gqlInstance }: ENSArgs<'gqlInstance'>,
   { name, page, pageSize = 10, orderDirection, orderBy }: Params,
 ) => {
-  const client = gqlInstance.client
+  const { client } = gqlInstance
   const subdomainsGql = `
   id
   labelName

package/src/{tests → functions}/makeCommitment.test.ts

@@ -1,21 +1,21 @@
 import { ENS } from '..'
+import setup from '../tests/setup'
 import { makeCommitment } from '../utils/registerHelpers'
-import setup from './setup'
 
-let ENSInstance: ENS
+let ensInstance: ENS
 
 beforeAll(async () => {
-  ;({ ENSInstance } = await setup())
+  ;({ ensInstance } = await setup())
 })
 
 describe('makeCommitment', () => {
   it('should create a valid commitment', async () => {
-    const resolver = await ENSInstance.contracts!.getPublicResolver()!
+    const resolver = await ensInstance.contracts!.getPublicResolver()!
     const commitment = makeCommitment({
       name: 'test.eth',
-      owner: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+      owner: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
       duration: 1 * 365 * 24 * 60 * 60,
-      resolver: resolver,
+      resolver,
     })
     expect(commitment).toHaveProperty('secret')
     expect(commitment).toHaveProperty('commitment')

package/src/functions/registerName.test.ts

@@ -0,0 +1,59 @@
+import { ethers } from 'ethers'
+import { ENS } from '..'
+import setup from '../tests/setup'
+import { namehash } from '../utils/normalise'
+
+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())
+  accounts = await provider.listAccounts()
+})
+
+afterAll(async () => {
+  await revert()
+  await provider.send('anvil_removeBlockTimestampInterval', [])
+})
+
+describe('registerName', () => {
+  beforeEach(async () => {
+    await revert()
+  })
+  it('should return a registration transaction and succeed', async () => {
+    const name = 'cool-swag.eth'
+    const duration = 31536000
+    const { customData, ...commitPopTx } =
+      await ensInstance.commitName.populateTransaction(name, {
+        duration,
+        owner: accounts[1],
+        addressOrIndex: accounts[1],
+      })
+    const commitTx = await provider.getSigner().sendTransaction(commitPopTx)
+    await commitTx.wait()
+
+    await provider.send('evm_increaseTime', [60])
+    await provider.send('evm_mine', [])
+
+    const { secret, wrapperExpiry } = 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],
+      value: price,
+    })
+    await tx.wait()
+
+    const nameWrapper = await ensInstance.contracts!.getNameWrapper()!
+    const owner = await nameWrapper.ownerOf(namehash(name))
+    expect(owner).toBe(accounts[1])
+  })
+})

package/src/functions/registerName.ts

@@ -0,0 +1,38 @@
+import { BigNumber } from 'ethers'
+import { ENSArgs } from '..'
+import {
+  CommitmentParams,
+  makeRegistrationData,
+} from '../utils/registerHelpers'
+
+type Params = Omit<CommitmentParams, 'name' | 'resolver'> & {
+  resolverAddress?: string
+  secret: string
+  wrapperExpiry: number
+  value: BigNumber
+}
+
+export default async function (
+  { contracts }: ENSArgs<'contracts'>,
+  name: string,
+  { resolverAddress, value, ...params }: Params,
+) {
+  const labels = name.split('.')
+  if (labels.length !== 2 || labels[1] !== 'eth')
+    throw new Error('Currently only .eth TLD registrations are supported')
+
+  const controller = await contracts!.getEthRegistrarController()
+  const _resolver = await contracts!.getPublicResolver(
+    undefined,
+    resolverAddress,
+  )
+  const generatedParams = makeRegistrationData({
+    name,
+    resolver: _resolver,
+    ...params,
+  })
+
+  return controller.populateTransaction.register(...generatedParams, {
+    value,
+  })
+}

package/src/functions/renewName.test.ts

@@ -0,0 +1,44 @@
+import { ethers } from 'ethers'
+import { ENS } from '..'
+import setup from '../tests/setup'
+import { labelhash } from '../utils/labels'
+
+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())
+  accounts = await provider.listAccounts()
+})
+
+afterAll(async () => {
+  await revert()
+})
+
+describe('registerName', () => {
+  beforeEach(async () => {
+    await revert()
+  })
+  it('should return a renew transaction and succeed', async () => {
+    const name = 'to-be-renewed.eth'
+    const label = name.split('.')[0]
+    const duration = 31536000
+    const baseRegistrar = await ensInstance.contracts!.getBaseRegistrar()!
+    const oldExpiry = await baseRegistrar.nameExpires(labelhash(label))
+
+    const controller = await ensInstance.contracts!.getEthRegistrarController()!
+    const [price] = await controller.rentPrice(label, duration)
+
+    const tx = await ensInstance.renewName(name, {
+      value: price.mul(2),
+      duration,
+      addressOrIndex: accounts[1],
+    })
+    await tx.wait()
+
+    const newExpiry = await baseRegistrar.nameExpires(labelhash(label))
+    expect(newExpiry.toNumber()).toBe(oldExpiry.add(31536000).toNumber())
+  })
+})

package/src/functions/renewName.ts

@@ -0,0 +1,22 @@
+import type { BigNumber } from 'ethers'
+import { ENSArgs } from '..'
+
+export default async function (
+  { contracts }: ENSArgs<'contracts'>,
+  name: string,
+  {
+    duration,
+    value,
+  }: {
+    duration: number
+    value: BigNumber
+  },
+) {
+  const labels = name.split('.')
+  if (labels.length !== 2 || labels[1] !== 'eth')
+    throw new Error('Currently only .eth TLD renewals are supported')
+
+  const controller = await contracts!.getEthRegistrarController()
+
+  return controller.populateTransaction.renew(labels[0], duration, { value })
+}

package/src/{tests → functions}/setName.test.ts

@@ -1,15 +1,15 @@
 import { ethers } from 'ethers'
 import { ENS } from '..'
+import setup from '../tests/setup'
 import { hexEncodeName } from '../utils/hexEncodedName'
-import setup from './setup'
 
-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,37 +22,37 @@ describe('setName', () => {
     await revert()
   })
   it('should return a transaction for a name and set successfully', async () => {
-    const tx = await ENSInstance.setName('fleek.eth')
+    const tx = await ensInstance.setName('test123.eth', { addressOrIndex: 1 })
     expect(tx).toBeTruthy()
     await tx?.wait()
 
     const universalResolver =
-      await ENSInstance.contracts!.getUniversalResolver()!
-    const reverseNode = accounts[0].toLowerCase().substring(2) + '.addr.reverse'
+      await ensInstance.contracts!.getUniversalResolver()!
+    const reverseNode = `${accounts[1].toLowerCase().substring(2)}.addr.reverse`
     const result = await universalResolver.reverse(hexEncodeName(reverseNode))
-    expect(result[0]).toBe('fleek.eth')
+    expect(result[0]).toBe('test123.eth')
   })
   it("should return a transaction for setting another address' name", async () => {
-    jest.setTimeout(20000)
-    const registry = (await ENSInstance.contracts!.getRegistry()!).connect(
-      provider.getSigner(),
+    const registry = (await ensInstance.contracts!.getRegistry()!).connect(
+      provider.getSigner(1),
     )
     const setApprovedForAllTx = await registry.setApprovalForAll(
-      accounts[1],
+      accounts[2],
       true,
     )
     await setApprovedForAllTx?.wait()
 
-    const tx = await ENSInstance.setName('fleek.eth', accounts[0], undefined, {
-      addressOrIndex: 1,
+    const tx = await ensInstance.setName('test123.eth', {
+      address: accounts[1],
+      addressOrIndex: 2,
     })
     expect(tx).toBeTruthy()
     await tx?.wait()
 
     const universalResolver =
-      await ENSInstance.contracts!.getUniversalResolver()!
-    const reverseNode = accounts[0].toLowerCase().substring(2) + '.addr.reverse'
+      await ensInstance.contracts!.getUniversalResolver()!
+    const reverseNode = `${accounts[1].toLowerCase().substring(2)}.addr.reverse`
     const result = await universalResolver.reverse(hexEncodeName(reverseNode))
-    expect(result[0]).toBe('fleek.eth')
+    expect(result[0]).toBe('test123.eth')
   })
 })

package/src/functions/setName.ts

@@ -1,34 +1,32 @@
 import { ENSArgs } from '..'
 
 export default async function (
-  { contracts, provider }: ENSArgs<'contracts' | 'provider'>,
+  { contracts, signer }: ENSArgs<'contracts' | 'signer'>,
   name: string,
-  address?: string,
-  resolver?: string,
-  options?: { addressOrIndex?: string | number },
+  {
+    address,
+    resolver,
+  }: {
+    address?: string
+    resolver?: string
+  } = {},
 ) {
-  const signerAddress = await provider
-    ?.getSigner(options?.addressOrIndex)
-    .getAddress()
-
-  if (!signerAddress) {
-    throw new Error('No signer found')
-  }
+  const signerAddress = await signer.getAddress()
 
   const reverseRegistrar = (await contracts?.getReverseRegistrar())?.connect(
-    provider?.getSigner()!,
-  )
+    signer,
+  )!
 
   if (address) {
-    const publicResolver = await contracts?.getPublicResolver()
+    const publicResolver = await contracts?.getPublicResolver()!
 
-    return reverseRegistrar?.setNameForAddr(
+    return reverseRegistrar.populateTransaction.setNameForAddr(
       address,
       signerAddress,
-      resolver || publicResolver!.address,
+      resolver || publicResolver.address,
       name,
     )
   }
 
-  return reverseRegistrar?.setName(name)
+  return reverseRegistrar.populateTransaction.setName(name)
 }