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

package/src/functions/getSubnames.ts

@@ -21,23 +21,52 @@ type Params = {
   pageSize?: number
   orderDirection?: 'asc' | 'desc'
   orderBy?: 'createdAt' | 'labelName'
-  lastSubnames: Array<any>
-  isLargeQuery?: boolean
+  lastSubnames?: Array<any>
+  search?: string
 }
 
 const largeQuery = async (
   { gqlInstance }: ENSArgs<'gqlInstance'>,
-  { name, page, pageSize = 10, orderDirection, orderBy, lastSubnames }: Params,
+  {
+    name,
+    pageSize = 10,
+    orderDirection,
+    orderBy,
+    lastSubnames = [],
+    search = '',
+  }: Params,
 ) => {
-  const client = gqlInstance.client
+  const { client } = gqlInstance
+
+  const lastSubname = lastSubnames?.[lastSubnames.length - 1]
+  const lastCreatedAt = lastSubname?.createdAt
+  const lastLabelName = lastSubname?.labelName
 
-  let finalQuery = gqlInstance.gql`
+  let whereFilter = ''
+  if (orderBy === 'createdAt' && lastCreatedAt) {
+    whereFilter +=
+      orderDirection === 'asc'
+        ? 'createdAt_gt: $lastCreatedAt'
+        : 'createdAt_lt: $lastCreatedAt'
+  } else if (orderBy === 'labelName' && lastLabelName) {
+    whereFilter +=
+      orderDirection === 'asc'
+        ? 'labelName_gt: $lastLabelName'
+        : 'labelName_lt: $lastLabelName'
+  }
+  if (search) {
+    whereFilter += ' labelName_contains: $search'
+  }
+
+  const finalQuery = gqlInstance.gql`
     query getSubnames(
       $id: ID! 
       $first: Int
       $lastCreatedAt: BigInt
+      $lastLabelName: String
       $orderBy: Domain_orderBy 
       $orderDirection: OrderDirection
+      $search: String
     ) {
       domain(
         id: $id
@@ -47,7 +76,9 @@ const largeQuery = async (
           first: $first
           orderBy: $orderBy
           orderDirection: $orderDirection
-          where: { createdAt_lt: $lastCreatedAt }
+          where: { 
+            ${whereFilter}
+          }
         ) {
           id
           labelName
@@ -63,107 +94,20 @@ const largeQuery = async (
       }
     }
   `
-  let queryVars = {
+
+  const queryVars = {
     id: namehash(name),
     first: pageSize,
-    lastCreatedAt: lastSubnames[lastSubnames.length - 1]?.createdAt,
+    lastCreatedAt,
+    lastLabelName,
     orderBy,
     orderDirection,
+    search: search?.toLowerCase(),
   }
   const { domain } = await client.request(finalQuery, queryVars)
   const subdomains = domain.subdomains.map((subname: any) => {
     const decrypted = decryptName(subname.name)
-    return {
-      ...subname,
-      name: decrypted,
-      truncatedName: truncateFormat(decrypted),
-    }
-  })
 
-  return {
-    subnames: subdomains,
-    subnameCount: domain.subdomainCount,
-  }
-}
-
-const smallQuery = async (
-  { gqlInstance }: ENSArgs<'gqlInstance'>,
-  { name, page, pageSize = 10, orderDirection, orderBy }: Params,
-) => {
-  const client = gqlInstance.client
-  const subdomainsGql = `
-  id
-  labelName
-  labelhash
-  isMigrated
-  name
-  subdomainCount
-  createdAt
-  owner {
-    id
-  }
-`
-  let queryVars = {}
-  let finalQuery = ''
-  if (typeof page !== 'number') {
-    finalQuery = gqlInstance.gql`
-    query getSubnames(
-      $id: ID! 
-      $orderBy: Domain_orderBy 
-      $orderDirection: OrderDirection
-    ) {
-      domain(
-        id: $id
-      ) {
-        subdomains(
-          orderBy: $orderBy
-          orderDirection: $orderDirection
-        ) {
-          ${subdomainsGql}
-        }
-      }
-    }
-  `
-    queryVars = {
-      id: namehash(name),
-      orderBy,
-      orderDirection,
-    }
-  } else {
-    finalQuery = gqlInstance.gql`
-    query getSubnames(
-      $id: ID! 
-      $first: Int
-      $skip: Int
-      $orderBy: Domain_orderBy 
-      $orderDirection: OrderDirection
-    ) {
-      domain(
-        id: $id
-      ) {
-        subdomainCount
-        subdomains(
-          first: $first
-          skip: $skip
-          orderBy: $orderBy
-          orderDirection: $orderDirection
-        ) {
-          ${subdomainsGql}
-        }
-      }
-    }
-  `
-    queryVars = {
-      id: namehash(name),
-      first: pageSize,
-      skip: (page || 0) * pageSize,
-      orderBy,
-      orderDirection,
-    }
-  }
-  const { domain } = await client.request(finalQuery, queryVars)
-  const subdomains = domain.subdomains.map((subname: any) => {
-    const decrypted = decryptName(subname.name)
     return {
       ...subname,
       name: decrypted,
@@ -181,10 +125,7 @@ const getSubnames = (
   injected: ENSArgs<'gqlInstance'>,
   functionArgs: Params,
 ): Promise<{ subnames: Subname[]; subnameCount: number }> => {
-  if (functionArgs.isLargeQuery) {
-    return largeQuery(injected, functionArgs)
-  }
-  return smallQuery(injected, functionArgs)
+  return largeQuery(injected, functionArgs)
 }
 
 export default getSubnames

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/renewNames.test.ts

@@ -0,0 +1,64 @@
+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('renewNames', () => {
+  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.renewNames(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())
+  })
+
+  it('should return a renew transaction and succeed', async () => {
+    const names = ['to-be-renewed.eth', 'test123.eth']
+    const label = names[0].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.renewNames(names, {
+      value: price.mul(4),
+      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/renewNames.ts

@@ -0,0 +1,30 @@
+import { BigNumber } from 'ethers'
+import { ENSArgs } from '..'
+
+export default async function (
+  { contracts }: ENSArgs<'contracts'>,
+  nameOrNames: string | string[],
+  {
+    duration,
+    value,
+  }: {
+    duration: number
+    value: BigNumber
+  },
+) {
+  const names = Array.isArray(nameOrNames) ? nameOrNames : [nameOrNames]
+  const labels = names.map((name) => {
+    const label = name.split('.')
+    if (label.length !== 2 || label[1] !== 'eth') {
+      throw new Error('Currently only .eth TLD renewals are supported')
+    }
+    return label[0]
+  })
+
+  if (labels.length === 1) {
+    const controller = await contracts!.getEthRegistrarController()
+    return controller.populateTransaction.renew(labels[0], duration, { value })
+  }
+  const bulkRenewal = await contracts!.getBulkRenewal()
+  return bulkRenewal.populateTransaction.renewAll(labels, 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)
 }

package/src/functions/setRecord.test.ts

@@ -0,0 +1,103 @@
+import { ENS } from '..'
+import setup from '../tests/setup'
+import { decodeContenthash } from '../utils/contentHash'
+import { hexEncodeName } from '../utils/hexEncodedName'
+import { namehash } from '../utils/normalise'
+
+let ensInstance: ENS
+let revert: Awaited<ReturnType<typeof setup>>['revert']
+
+beforeAll(async () => {
+  ;({ ensInstance, revert } = await setup())
+})
+
+afterAll(async () => {
+  await revert()
+})
+
+describe('setRecord', () => {
+  it('should allow a text record set', async () => {
+    const tx = await ensInstance.setRecord('test123.eth', {
+      type: 'text',
+      record: { key: 'foo', value: 'bar' },
+      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('test123.eth'),
+      publicResolver.interface.encodeFunctionData('text', [
+        namehash('test123.eth'),
+        'foo',
+      ]),
+    )
+    const [resultText] = publicResolver.interface.decodeFunctionResult(
+      'text',
+      encodedText[0],
+    )
+    expect(resultText).toBe('bar')
+  })
+  it('should allow an address record set', async () => {
+    const tx = await ensInstance.setRecord('test123.eth', {
+      type: 'addr',
+      record: {
+        key: 'ETC',
+        value: '0x42D63ae25990889E35F215bC95884039Ba354115',
+      },
+      addressOrIndex: 1,
+    })
+    expect(tx).toBeTruthy()
+    await tx.wait()
+
+    const universalResolver =
+      await ensInstance.contracts!.getUniversalResolver()!
+    const publicResolver = await ensInstance.contracts!.getPublicResolver()!
+    const encodedAddr = await universalResolver.resolve(
+      hexEncodeName('test123.eth'),
+      publicResolver.interface.encodeFunctionData('addr(bytes32,uint256)', [
+        namehash('test123.eth'),
+        '61',
+      ]),
+    )
+    const [resultAddr] = publicResolver.interface.decodeFunctionResult(
+      'addr(bytes32,uint256)',
+      encodedAddr[0],
+    )
+    expect(resultAddr).toBe(
+      '0x42D63ae25990889E35F215bC95884039Ba354115'.toLowerCase(),
+    )
+  })
+  it('should allow a contenthash record set', async () => {
+    const tx = await ensInstance.setRecord('test123.eth', {
+      type: 'contentHash',
+      record:
+        'ipns://k51qzi5uqu5dgox2z23r6e99oqency055a6xt92xzmyvpz8mwz5ycjavm0u150',
+      addressOrIndex: 1,
+    })
+    expect(tx).toBeTruthy()
+    await tx.wait()
+
+    const universalResolver =
+      await ensInstance.contracts!.getUniversalResolver()!
+    const publicResolver = await ensInstance.contracts!.getPublicResolver()!
+    const encodedContent = await universalResolver.resolve(
+      hexEncodeName('test123.eth'),
+      publicResolver.interface.encodeFunctionData('contenthash', [
+        namehash('test123.eth'),
+      ]),
+    )
+    const [resultContent] = publicResolver.interface.decodeFunctionResult(
+      'contenthash',
+      encodedContent[0],
+    )
+    const content = decodeContenthash(resultContent)
+    expect(content.decoded).toBe(
+      'k51qzi5uqu5dgox2z23r6e99oqency055a6xt92xzmyvpz8mwz5ycjavm0u150',
+    )
+    expect(content.protocolType).toBe('ipns')
+  })
+})