@ensdomains/ensjs 3.0.0-beta.1 → 3.0.0-beta.2

package/src/functions/subgraph/getSubnames.test.ts

@@ -1,202 +0,0 @@
-/* eslint-disable no-await-in-loop */
-
-import { publicClient } from '../../tests/addTestContracts.js'
-import getSubnames from './getSubnames.js'
-import type { Name } from './utils.js'
-
-it('returns with default values', async () => {
-  const result = await getSubnames(publicClient, {
-    name: 'with-subnames.eth',
-  })
-
-  expect(result).toBeTruthy()
-  // arbitrary number, just to make sure we get some results
-  expect(result.length).toBeGreaterThan(2)
-})
-
-it('has registration date on .eth names', async () => {
-  const result = await getSubnames(publicClient, {
-    name: 'eth',
-  })
-
-  if (!result.length) throw new Error('No names found')
-  for (const name of result) {
-    expect(name.registrationDate).toBeTruthy()
-  }
-})
-
-it('filters by search string', async () => {
-  const result = await getSubnames(publicClient, {
-    name: 'eth',
-    searchString: 'test',
-  })
-
-  if (!result.length) throw new Error('No names found')
-  for (const name of result) {
-    expect(name.labelName).toContain('test')
-  }
-})
-it('does not include expired names by default - .eth 2ld', async () => {
-  const result = await getSubnames(publicClient, {
-    name: 'eth',
-    pageSize: 1000,
-  })
-  if (!result.length) throw new Error('No names found')
-  for (const name of result) {
-    expect(name.expiryDate!.value).toBeGreaterThan(Date.now())
-  }
-})
-it('allows including expired names - .eth 2ld', async () => {
-  const result = await getSubnames(publicClient, {
-    name: 'eth',
-    allowExpired: true,
-    pageSize: 1000,
-  })
-  if (!result.length) throw new Error('No names found')
-  const expiredNames = result.filter(
-    (name) => name.expiryDate!.value < Date.now(),
-  )
-  expect(expiredNames.length).toBeGreaterThan(0)
-})
-it('includes names with no expiry', async () => {
-  const result = await getSubnames(publicClient, {
-    name: 'wrapped-with-expiring-subnames.eth',
-    pageSize: 1000,
-  })
-  if (!result.length) throw new Error('No names found')
-  const noExpiryNames = result.filter((name) => !name.expiryDate)
-  expect(noExpiryNames.length).toBeGreaterThan(0)
-})
-it('does not include expired names by default - other', async () => {
-  const result = await getSubnames(publicClient, {
-    name: 'wrapped-with-expiring-subnames.eth',
-    pageSize: 1000,
-  })
-  if (!result.length) throw new Error('No names found')
-  const namesWithExpiry = result.filter((name) => name.expiryDate)
-  expect(namesWithExpiry.length).toBeGreaterThan(0)
-  for (const name of namesWithExpiry) {
-    expect(name.expiryDate!.value).toBeGreaterThan(Date.now())
-  }
-})
-it('allows including expired names - other', async () => {
-  const result = await getSubnames(publicClient, {
-    name: 'wrapped-with-expiring-subnames.eth',
-    allowExpired: true,
-    pageSize: 1000,
-  })
-  if (!result.length) throw new Error('No names found')
-  const expiredNames = result.filter(
-    (name) => name.expiryDate && name.expiryDate.value < Date.now(),
-  )
-  expect(expiredNames.length).toBeGreaterThan(0)
-})
-
-describe.each([
-  {
-    orderBy: 'name',
-    orderDirection: 'asc',
-    compareFn: (a: Name, b: Name) => (a.name || '').localeCompare(b.name || ''),
-  },
-  {
-    orderBy: 'name',
-    orderDirection: 'desc',
-    compareFn: (a: Name, b: Name) => (b.name || '').localeCompare(a.name || ''),
-  },
-  {
-    orderBy: 'labelName',
-    orderDirection: 'asc',
-    compareFn: (a: Name, b: Name) => {
-      const aLabelName = a.labelName || ''
-      const bLabelName = b.labelName || ''
-      return aLabelName.localeCompare(bLabelName)
-    },
-  },
-  {
-    orderBy: 'labelName',
-    orderDirection: 'desc',
-    compareFn: (a: Name, b: Name) => {
-      const aLabelName = a.labelName || ''
-      const bLabelName = b.labelName || ''
-      return bLabelName.localeCompare(aLabelName)
-    },
-  },
-  {
-    orderBy: 'expiryDate',
-    orderDirection: 'asc',
-    compareFn: (a: Name, b: Name) => {
-      const aExpiryDate = a.expiryDate?.value || Infinity
-      const bExpiryDate = b.expiryDate?.value || Infinity
-      return aExpiryDate - bExpiryDate
-    },
-  },
-  {
-    orderBy: 'expiryDate',
-    orderDirection: 'desc',
-    compareFn: (a: Name, b: Name) => {
-      const aExpiryDate = a.expiryDate?.value || Infinity
-      const bExpiryDate = b.expiryDate?.value || Infinity
-      return bExpiryDate - aExpiryDate
-    },
-  },
-  {
-    orderBy: 'createdAt',
-    orderDirection: 'asc',
-    compareFn: (a: Name, b: Name) => {
-      const aCreatedAt = a.createdAt.value
-      const bCreatedAt = b.createdAt.value
-      return aCreatedAt - bCreatedAt
-    },
-  },
-  {
-    orderBy: 'createdAt',
-    orderDirection: 'desc',
-    compareFn: (a: Name, b: Name) => {
-      const aCreatedAt = a.createdAt.value
-      const bCreatedAt = b.createdAt.value
-      return bCreatedAt - aCreatedAt
-    },
-  },
-])(
-  'filters by $orderBy $orderDirection',
-  ({ orderBy, orderDirection, compareFn }) => {
-    it('is consistent between full result and paginated results', async () => {
-      const fullResult = await getSubnames(publicClient, {
-        name: 'eth',
-        orderBy: orderBy as any,
-        orderDirection: orderDirection as any,
-        pageSize: 1000,
-      })
-      if (!fullResult.length) throw new Error('No names found')
-      const paginatedResults = []
-      let lastResult: Name[] = []
-      do {
-        const result = await getSubnames(publicClient, {
-          name: 'eth',
-          orderBy: orderBy as any,
-          orderDirection: orderDirection as any,
-          previousPage: lastResult,
-          pageSize: 5,
-        })
-        paginatedResults.push(...result)
-        lastResult = result
-      } while (lastResult.length)
-
-      expect(paginatedResults.length).toBe(fullResult.length)
-      expect(JSON.stringify(paginatedResults)).toEqual(
-        JSON.stringify(fullResult),
-      )
-    })
-    it('is sorted correctly', async () => {
-      const fullResult = await getSubnames(publicClient, {
-        name: 'eth',
-        orderBy: orderBy as any,
-        orderDirection: orderDirection as any,
-        pageSize: 1000,
-      })
-      if (!fullResult.length) throw new Error('No names found')
-      const sortedResult = [...fullResult].sort(compareFn)
-      expect(fullResult).toStrictEqual(sortedResult)
-    })
-  },
-)

package/src/functions/wallet/commitName.test.ts

@@ -1,58 +0,0 @@
-import type { Address, Hex } from 'viem'
-import { ethRegistrarControllerCommitmentsSnippet } from '../../contracts/ethRegistrarController.js'
-import { getChainContractAddress } from '../../contracts/getChainContractAddress.js'
-import {
-  publicClient,
-  testClient,
-  waitForTransaction,
-  walletClient,
-} from '../../tests/addTestContracts.js'
-import {
-  makeCommitment,
-  type RegistrationParameters,
-} from '../../utils/registerHelpers.js'
-import commitName from './commitName.js'
-
-let snapshot: Hex
-let accounts: Address[]
-
-beforeAll(async () => {
-  accounts = await walletClient.getAddresses()
-})
-
-beforeEach(async () => {
-  snapshot = await testClient.snapshot()
-})
-
-afterEach(async () => {
-  await testClient.revert({ id: snapshot })
-})
-
-const secret = `0x${'a'.repeat(64)}` as Hex
-
-it('should return a commit transaction and succeed', async () => {
-  const params: RegistrationParameters = {
-    name: 'wrapped-with-subnames.eth',
-    duration: 31536000,
-    owner: accounts[1],
-    secret,
-  }
-  const tx = await commitName(walletClient, {
-    ...params,
-    account: accounts[1],
-  })
-  expect(tx).toBeTruthy()
-  const receipt = await waitForTransaction(tx)
-  expect(receipt.status).toBe('success')
-
-  const commitment = await publicClient.readContract({
-    abi: ethRegistrarControllerCommitmentsSnippet,
-    functionName: 'commitments',
-    address: getChainContractAddress({
-      client: publicClient,
-      contract: 'ensEthRegistrarController',
-    }),
-    args: [makeCommitment(params)],
-  })
-  expect(commitment).toBeTruthy()
-})

package/src/functions/wallet/createSubname.test.ts

@@ -1,73 +0,0 @@
-import type { Address, Hex } from 'viem'
-import { getChainContractAddress } from '../../contracts/getChainContractAddress.js'
-import { nameWrapperOwnerOfSnippet } from '../../contracts/nameWrapper.js'
-import { registryOwnerSnippet } from '../../contracts/registry.js'
-import {
-  publicClient,
-  testClient,
-  waitForTransaction,
-  walletClient,
-} from '../../tests/addTestContracts.js'
-import { namehash } from '../../utils/normalise.js'
-import createSubname from './createSubname.js'
-
-let snapshot: Hex
-let accounts: Address[]
-
-beforeAll(async () => {
-  accounts = await walletClient.getAddresses()
-})
-
-beforeEach(async () => {
-  snapshot = await testClient.snapshot()
-})
-
-afterEach(async () => {
-  await testClient.revert({ id: snapshot })
-})
-
-it('should allow creating a subname on the registry', async () => {
-  const tx = await createSubname(walletClient, {
-    name: 'test.test123.eth',
-    contract: 'registry',
-    owner: accounts[0],
-    account: accounts[1],
-  })
-  expect(tx).toBeTruthy()
-  const receipt = await waitForTransaction(tx)
-  expect(receipt.status).toBe('success')
-
-  const owner = await publicClient.readContract({
-    abi: registryOwnerSnippet,
-    functionName: 'owner',
-    address: getChainContractAddress({
-      client: publicClient,
-      contract: 'ensRegistry',
-    }),
-    args: [namehash('test.test123.eth')],
-  })
-  expect(owner).toBe(accounts[0])
-})
-
-it('should allow creating a subname on the namewrapper', async () => {
-  const tx = await createSubname(walletClient, {
-    name: 'test.wrapped.eth',
-    contract: 'nameWrapper',
-    owner: accounts[0],
-    account: accounts[1],
-  })
-  expect(tx).toBeTruthy()
-  const receipt = await waitForTransaction(tx)
-  expect(receipt.status).toBe('success')
-
-  const owner = await publicClient.readContract({
-    abi: nameWrapperOwnerOfSnippet,
-    functionName: 'ownerOf',
-    address: getChainContractAddress({
-      client: publicClient,
-      contract: 'ensNameWrapper',
-    }),
-    args: [BigInt(namehash('test.wrapped.eth'))],
-  })
-  expect(owner).toBe(accounts[0])
-})

package/src/functions/wallet/deleteSubname.test.ts

@@ -1,150 +0,0 @@
-import type { Address, Hex } from 'viem'
-import { getChainContractAddress } from '../../contracts/getChainContractAddress.js'
-import { nameWrapperOwnerOfSnippet } from '../../contracts/nameWrapper.js'
-import {
-  registryOwnerSnippet,
-  registryResolverSnippet,
-} from '../../contracts/registry.js'
-import {
-  publicClient,
-  testClient,
-  waitForTransaction,
-  walletClient,
-} from '../../tests/addTestContracts.js'
-import { EMPTY_ADDRESS } from '../../utils/consts.js'
-import { namehash } from '../../utils/normalise.js'
-import deleteSubname from './deleteSubname.js'
-
-let snapshot: Hex
-let accounts: Address[]
-
-beforeAll(async () => {
-  accounts = await walletClient.getAddresses()
-})
-
-beforeEach(async () => {
-  snapshot = await testClient.snapshot()
-})
-
-afterEach(async () => {
-  await testClient.revert({ id: snapshot })
-})
-
-const getOwner = async (name: string) => {
-  return publicClient.readContract({
-    abi: registryOwnerSnippet,
-    functionName: 'owner',
-    address: getChainContractAddress({
-      client: publicClient,
-      contract: 'ensRegistry',
-    }),
-    args: [namehash(name)],
-  })
-}
-
-const getNameWrapperOwner = async (name: string) => {
-  return publicClient.readContract({
-    abi: nameWrapperOwnerOfSnippet,
-    functionName: 'ownerOf',
-    address: getChainContractAddress({
-      client: publicClient,
-      contract: 'ensNameWrapper',
-    }),
-    args: [BigInt(namehash(name))],
-  })
-}
-
-const getResolver = async (name: string) => {
-  return publicClient.readContract({
-    abi: registryResolverSnippet,
-    functionName: 'resolver',
-    address: getChainContractAddress({
-      client: publicClient,
-      contract: 'ensRegistry',
-    }),
-    args: [namehash(name)],
-  })
-}
-
-it('should allow deleting a subname on the registry by parent owner', async () => {
-  const tx = await deleteSubname(walletClient, {
-    name: 'test.with-subnames.eth',
-    contract: 'registry',
-    account: accounts[1],
-  })
-  expect(tx).toBeTruthy()
-  const receipt = await waitForTransaction(tx)
-  expect(receipt.status).toBe('success')
-
-  const owner = await getOwner('test.with-subnames.eth')
-  expect(owner).toBe(EMPTY_ADDRESS)
-
-  const resolver = await getResolver('test.with-subnames.eth')
-  expect(resolver).toBe(EMPTY_ADDRESS)
-})
-
-it('should allow deleting a subname on the namewrapper by parent owner', async () => {
-  const tx = await deleteSubname(walletClient, {
-    name: 'test.wrapped-with-subnames.eth',
-    contract: 'nameWrapper',
-    account: accounts[1],
-  })
-  expect(tx).toBeTruthy()
-  const receipt = await waitForTransaction(tx)
-  expect(receipt.status).toBe('success')
-
-  const owner = await getOwner('test.wrapped-with-subnames.eth')
-  expect(owner).toBe(EMPTY_ADDRESS)
-
-  const resolver = await getResolver('test.wrapped-with-subnames.eth')
-  expect(resolver).toBe(EMPTY_ADDRESS)
-
-  const nameWrapperOwner = await getNameWrapperOwner(
-    'test.wrapped-with-subnames.eth',
-  )
-  expect(nameWrapperOwner).toBe(EMPTY_ADDRESS)
-})
-
-it('should allow deleting a subname on the namewrapper by name owner', async () => {
-  const tx = await deleteSubname(walletClient, {
-    name: 'addr.wrapped-with-subnames.eth',
-    contract: 'nameWrapper',
-    asOwner: true,
-    account: accounts[2],
-  })
-  expect(tx).toBeTruthy()
-  const receipt = await waitForTransaction(tx)
-  expect(receipt.status).toBe('success')
-
-  const owner = await getOwner('addr.wrapped-with-subnames.eth')
-  expect(owner).toBe(EMPTY_ADDRESS)
-
-  const resolver = await getResolver('addr.wrapped-with-subnames.eth')
-  expect(resolver).toBe(EMPTY_ADDRESS)
-
-  const nameWrapperOwner = await getNameWrapperOwner(
-    'addr.wrapped-with-subnames.eth',
-  )
-  expect(nameWrapperOwner).toBe(EMPTY_ADDRESS)
-})
-
-it('should not allow deleting top level domain', async () => {
-  await expect(
-    deleteSubname(walletClient, {
-      name: 'eth',
-      contract: 'nameWrapper',
-      asOwner: true,
-      account: accounts[1],
-    }),
-  ).rejects.toThrow()
-})
-
-it('should not allow deleting second level domain', async () => {
-  await expect(
-    deleteSubname(walletClient, {
-      name: 'test123.eth',
-      contract: 'registry',
-      account: accounts[1],
-    }),
-  ).rejects.toThrow()
-})

package/src/functions/wallet/registerName.test.ts

@@ -1,81 +0,0 @@
-import type { Address, Hex } from 'viem'
-import { getChainContractAddress } from '../../contracts/getChainContractAddress.js'
-import { nameWrapperOwnerOfSnippet } from '../../contracts/nameWrapper.js'
-import {
-  publicClient,
-  testClient,
-  waitForTransaction,
-  walletClient,
-} from '../../tests/addTestContracts.js'
-import { namehash } from '../../utils/normalise.js'
-import type { RegistrationParameters } from '../../utils/registerHelpers.js'
-import getPrice from '../public/getPrice.js'
-import commitName from './commitName.js'
-import registerName from './registerName.js'
-
-let snapshot: Hex
-let accounts: Address[]
-
-beforeAll(async () => {
-  accounts = await walletClient.getAddresses()
-})
-
-beforeEach(async () => {
-  snapshot = await testClient.snapshot()
-})
-
-afterEach(async () => {
-  await testClient.revert({ id: snapshot })
-})
-
-const secret = `0x${'a'.repeat(64)}` as Hex
-
-const getNameWrapperOwner = async (name: string) => {
-  return publicClient.readContract({
-    abi: nameWrapperOwnerOfSnippet,
-    functionName: 'ownerOf',
-    address: getChainContractAddress({
-      client: publicClient,
-      contract: 'ensNameWrapper',
-    }),
-    args: [BigInt(namehash(name))],
-  })
-}
-
-it('should return a registration transaction and succeed', async () => {
-  const params: RegistrationParameters = {
-    name: 'cool-swag.eth',
-    duration: 31536000,
-    owner: accounts[1],
-    secret,
-  }
-  const commitTx = await commitName(walletClient, {
-    ...params,
-    account: accounts[1],
-  })
-  expect(commitTx).toBeTruthy()
-  const commitReceipt = await waitForTransaction(commitTx)
-
-  expect(commitReceipt.status).toBe('success')
-
-  await testClient.increaseTime({ seconds: 61 })
-  await testClient.mine({ blocks: 1 })
-
-  const price = await getPrice(publicClient, {
-    nameOrNames: params.name,
-    duration: params.duration,
-  })
-  const total = price!.base + price!.premium
-
-  const tx = await registerName(walletClient, {
-    ...params,
-    account: accounts[1],
-    value: total,
-  })
-  expect(tx).toBeTruthy()
-  const receipt = await waitForTransaction(tx)
-  expect(receipt.status).toBe('success')
-
-  const owner = await getNameWrapperOwner(params.name)
-  expect(owner).toBe(accounts[1])
-})

package/src/functions/wallet/renewNames.test.ts

@@ -1,92 +0,0 @@
-import { labelhash, type Address, type Hex } from 'viem'
-import { baseRegistrarNameExpiresSnippet } from '../../contracts/baseRegistrar.js'
-import { getChainContractAddress } from '../../contracts/getChainContractAddress.js'
-import {
-  publicClient,
-  testClient,
-  waitForTransaction,
-  walletClient,
-} from '../../tests/addTestContracts.js'
-import getPrice from '../public/getPrice.js'
-import renewNames from './renewNames.js'
-
-let snapshot: Hex
-let accounts: Address[]
-
-beforeAll(async () => {
-  accounts = await walletClient.getAddresses()
-})
-
-beforeEach(async () => {
-  snapshot = await testClient.snapshot()
-})
-
-afterEach(async () => {
-  await testClient.revert({ id: snapshot })
-})
-
-const getExpiry = async (name: string) => {
-  return publicClient.readContract({
-    abi: baseRegistrarNameExpiresSnippet,
-    functionName: 'nameExpires',
-    address: getChainContractAddress({
-      client: publicClient,
-      contract: 'ensBaseRegistrarImplementation',
-    }),
-    args: [BigInt(labelhash(name.split('.')[0]))],
-  })
-}
-
-it('should return a renew transaction for a single name and succeed', async () => {
-  const name = 'to-be-renewed.eth'
-  const duration = 31536000n
-
-  const oldExpiry = await getExpiry(name)
-
-  const price = await getPrice(publicClient, {
-    nameOrNames: name,
-    duration,
-  })
-  const total = price!.base + price!.premium
-
-  const tx = await renewNames(walletClient, {
-    nameOrNames: name,
-    duration,
-    value: total,
-    account: accounts[0],
-  })
-  expect(tx).toBeTruthy()
-  const receipt = await waitForTransaction(tx)
-  expect(receipt.status).toBe('success')
-
-  const newExpiry = await getExpiry(name)
-  expect(newExpiry).toBe(oldExpiry + duration)
-})
-
-it('should return a renewAll transaction for multiple names and succeed', async () => {
-  const names = ['to-be-renewed.eth', 'test123.eth']
-  const duration = 31536000n
-
-  const oldExpiries = await Promise.all(names.map(getExpiry))
-
-  const price = await getPrice(publicClient, {
-    nameOrNames: names,
-    duration,
-  })
-  const total = price!.base + price!.premium
-
-  const tx = await renewNames(walletClient, {
-    nameOrNames: names,
-    duration,
-    value: total,
-    account: accounts[1],
-  })
-  expect(tx).toBeTruthy()
-  const receipt = await waitForTransaction(tx)
-  expect(receipt.status).toBe('success')
-
-  const newExpiries = await Promise.all(names.map(getExpiry))
-  for (let i = 0; i < names.length; i += 1) {
-    expect(newExpiries[i]).toBe(oldExpiries[i] + duration)
-  }
-})