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

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

@@ -1,244 +0,0 @@
-/* eslint-disable no-await-in-loop */
-
-import type { Address } from 'viem'
-import { publicClient, walletClient } from '../../tests/addTestContracts.js'
-import getNamesForAddress, {
-  type NameWithRelation,
-} from './getNamesForAddress.js'
-
-let accounts: Address[]
-
-beforeAll(async () => {
-  accounts = await walletClient.getAddresses()
-})
-
-it('returns with default values', async () => {
-  const result = await getNamesForAddress(publicClient, {
-    address: accounts[1],
-  })
-
-  expect(result).toBeTruthy()
-  // arbitrary number, just to make sure we get some results
-  expect(result.length).toBeGreaterThan(10)
-})
-
-it('has registration date on .eth names', async () => {
-  const result = await getNamesForAddress(publicClient, {
-    address: accounts[1],
-  })
-  if (!result.length) throw new Error('No names found')
-  for (const name of result) {
-    if (name.parentName === 'eth') {
-      expect(name.registrationDate).toBeTruthy()
-    }
-  }
-})
-describe('filter', () => {
-  it('filters by owner', async () => {
-    const result = await getNamesForAddress(publicClient, {
-      address: accounts[1],
-      filter: {
-        owner: true,
-        registrant: false,
-        resolvedAddress: false,
-        wrappedOwner: false,
-      },
-    })
-    if (!result.length) throw new Error('No names found')
-    for (const name of result) {
-      expect(name.owner).toBe(accounts[1])
-      expect(name.relation.owner).toBe(true)
-    }
-  })
-  it('filters by registrant', async () => {
-    const result = await getNamesForAddress(publicClient, {
-      address: accounts[1],
-      filter: {
-        owner: false,
-        registrant: true,
-        resolvedAddress: false,
-        wrappedOwner: false,
-      },
-    })
-    if (!result.length) throw new Error('No names found')
-    for (const name of result) {
-      expect(name.registrant).toBe(accounts[1])
-      expect(name.relation.registrant).toBe(true)
-    }
-  })
-  it('filters by resolved address', async () => {
-    const result = await getNamesForAddress(publicClient, {
-      address: accounts[1],
-      filter: {
-        owner: false,
-        registrant: false,
-        resolvedAddress: true,
-        wrappedOwner: false,
-      },
-    })
-    if (!result.length) throw new Error('No names found')
-    for (const name of result) {
-      expect(name.resolvedAddress).toBe(accounts[1])
-      expect(name.relation.resolvedAddress).toBe(true)
-    }
-  })
-  it('filters by wrapped owner', async () => {
-    const result = await getNamesForAddress(publicClient, {
-      address: accounts[1],
-      filter: {
-        owner: false,
-        registrant: false,
-        resolvedAddress: false,
-        wrappedOwner: true,
-      },
-    })
-    if (!result.length) throw new Error('No names found')
-    for (const name of result) {
-      expect(name.wrappedOwner).toBe(accounts[1])
-      expect(name.relation.wrappedOwner).toBe(true)
-    }
-  })
-  it('allows including expired names', async () => {
-    const result = await getNamesForAddress(publicClient, {
-      address: accounts[1],
-      filter: {
-        owner: true,
-        registrant: true,
-        resolvedAddress: true,
-        wrappedOwner: true,
-        allowExpired: true,
-      },
-    })
-    if (!result.length) throw new Error('No names found')
-    const expiredNames = result.filter(
-      (x) => x.expiryDate?.date && x.expiryDate.date < new Date(),
-    )
-    expect(expiredNames.length).toBeGreaterThan(0)
-  })
-  it('allows including reverse record', async () => {
-    const result = await getNamesForAddress(publicClient, {
-      address: accounts[2],
-      filter: {
-        owner: true,
-        registrant: true,
-        resolvedAddress: true,
-        wrappedOwner: true,
-        allowReverseRecord: true,
-      },
-    })
-    if (!result.length) throw new Error('No names found')
-    const reverseRecordNames = result.filter(
-      (x) => x.parentName === 'addr.reverse',
-    )
-    expect(reverseRecordNames.length).toBeGreaterThan(0)
-  })
-})
-
-describe.each([
-  {
-    orderBy: 'name',
-    orderDirection: 'asc',
-    compareFn: (a: NameWithRelation, b: NameWithRelation) =>
-      (a.name || '').localeCompare(b.name || ''),
-  },
-  {
-    orderBy: 'name',
-    orderDirection: 'desc',
-    compareFn: (a: NameWithRelation, b: NameWithRelation) =>
-      (b.name || '').localeCompare(a.name || ''),
-  },
-  {
-    orderBy: 'labelName',
-    orderDirection: 'asc',
-    compareFn: (a: NameWithRelation, b: NameWithRelation) => {
-      const aLabelName = a.labelName || ''
-      const bLabelName = b.labelName || ''
-      return aLabelName.localeCompare(bLabelName)
-    },
-  },
-  {
-    orderBy: 'labelName',
-    orderDirection: 'desc',
-    compareFn: (a: NameWithRelation, b: NameWithRelation) => {
-      const aLabelName = a.labelName || ''
-      const bLabelName = b.labelName || ''
-      return bLabelName.localeCompare(aLabelName)
-    },
-  },
-  {
-    orderBy: 'expiryDate',
-    orderDirection: 'asc',
-    compareFn: (a: NameWithRelation, b: NameWithRelation) => {
-      const aExpiryDate = a.expiryDate?.value || Infinity
-      const bExpiryDate = b.expiryDate?.value || Infinity
-      return aExpiryDate - bExpiryDate
-    },
-  },
-  {
-    orderBy: 'expiryDate',
-    orderDirection: 'desc',
-    compareFn: (a: NameWithRelation, b: NameWithRelation) => {
-      const aExpiryDate = a.expiryDate?.value || Infinity
-      const bExpiryDate = b.expiryDate?.value || Infinity
-      return bExpiryDate - aExpiryDate
-    },
-  },
-  {
-    orderBy: 'createdAt',
-    orderDirection: 'asc',
-    compareFn: (a: NameWithRelation, b: NameWithRelation) => {
-      const aCreatedAt = a.createdAt.value
-      const bCreatedAt = b.createdAt.value
-      return aCreatedAt - bCreatedAt
-    },
-  },
-  {
-    orderBy: 'createdAt',
-    orderDirection: 'desc',
-    compareFn: (a: NameWithRelation, b: NameWithRelation) => {
-      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 getNamesForAddress(publicClient, {
-        address: accounts[1],
-        orderBy: orderBy as any,
-        orderDirection: orderDirection as any,
-        pageSize: 1000,
-      })
-      if (!fullResult.length) throw new Error('No names found')
-      const paginatedResults = []
-      let lastResult: NameWithRelation[] = []
-      do {
-        const result = await getNamesForAddress(publicClient, {
-          address: accounts[1],
-          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(paginatedResults).toStrictEqual(fullResult)
-    })
-    it('is sorted correctly', async () => {
-      const fullResult = await getNamesForAddress(publicClient, {
-        address: accounts[1],
-        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).toEqual(sortedResult)
-    })
-  },
-)

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

@@ -1,74 +0,0 @@
-import {
-  deploymentAddresses,
-  publicClient,
-} from '../../tests/addTestContracts.js'
-import getSubgraphRecords from './getSubgraphRecords.js'
-
-it('gets basic records', async () => {
-  const result = await getSubgraphRecords(publicClient, {
-    name: 'with-profile.eth',
-  })
-  expect(result).toBeTruthy()
-  const { createdAt, ...snapshot } = result!
-  expect(createdAt.date).toBeInstanceOf(Date)
-  expect(createdAt.value).toBe(createdAt.date.getTime())
-  expect(snapshot).toMatchInlineSnapshot(`
-    {
-      "coins": [
-        "60",
-        "61",
-        "0",
-        "2",
-      ],
-      "isMigrated": true,
-      "texts": [
-        "description",
-        "url",
-        "blankrecord",
-        "email",
-      ],
-    }
-  `)
-})
-it('gets records for custom resolver address', async () => {
-  const result = await getSubgraphRecords(publicClient, {
-    name: 'with-legacy-resolver.eth',
-    resolverAddress: deploymentAddresses.LegacyPublicResolver,
-  })
-  expect(result).toBeTruthy()
-  const { createdAt, ...snapshot } = result!
-  expect(createdAt.date).toBeInstanceOf(Date)
-  expect(createdAt.value).toBe(createdAt.date.getTime())
-  expect(snapshot).toMatchInlineSnapshot(`
-    {
-      "coins": [
-        "60",
-      ],
-      "isMigrated": true,
-      "texts": [],
-    }
-  `)
-})
-it('returns null for nonexistent name', async () => {
-  const result = await getSubgraphRecords(publicClient, {
-    name: 'nonexistent.eth',
-  })
-  expect(result).toBeNull()
-})
-it('returns empty texts/coins for nonexistent resolver', async () => {
-  const result = await getSubgraphRecords(publicClient, {
-    name: 'with-profile.eth',
-    resolverAddress: '0xb794F5eA0ba39494cE839613fffBA74279579268',
-  })
-  expect(result).toBeTruthy()
-  const { createdAt, ...snapshot } = result!
-  expect(createdAt.date).toBeInstanceOf(Date)
-  expect(createdAt.value).toBe(createdAt.date.getTime())
-  expect(snapshot).toMatchInlineSnapshot(`
-    {
-      "coins": [],
-      "isMigrated": true,
-      "texts": [],
-    }
-  `)
-})

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

@@ -1,34 +0,0 @@
-import { getVersion } from '../../errors/error-utils.js'
-import {
-  deploymentAddresses,
-  publicClient,
-} from '../../tests/addTestContracts.js'
-import getSubgraphRegistrant from './getSubgraphRegistrant.js'
-
-it('gets the registrant for a 2ld .eth name', async () => {
-  const result = await getSubgraphRegistrant(publicClient, {
-    name: 'wrapped.eth',
-  })
-  expect(result).toBe(deploymentAddresses.NameWrapper)
-})
-it('returns null for nonexistent name', async () => {
-  const result = await getSubgraphRegistrant(publicClient, {
-    name: 'unregistered.eth',
-  })
-  expect(result).toBeNull()
-})
-it('throws an error for other name', async () => {
-  await expect(
-    getSubgraphRegistrant(publicClient, {
-      name: 'test123.com',
-    }),
-  ).rejects.toThrowErrorMatchingInlineSnapshot(`
-    "Unsupported name type: other-2ld
-
-    - Supported name types: eth-2ld
-
-    Details: Registrant can only be fetched for eth-2ld names
-
-    Version: ${getVersion()}"
-  `)
-})

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])
-})