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

package/src/functions/dns/prepareDnsImport.test.ts

@@ -1,115 +0,0 @@
-import { SignedSet } from '@ensdomains/dnsprovejs'
-import type { Address, Hex } from 'viem'
-import {
-  publicClient,
-  testClient,
-  waitForTransaction,
-  walletClient,
-} from '../../tests/addTestContracts.js'
-import importDnsName from './importDnsName.js'
-import prepareDnsImport, { type RrSetWithSig } from './prepareDnsImport.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 decodeProofs = (proofs: RrSetWithSig[]) =>
-  proofs.map((proof) =>
-    SignedSet.fromWire(proof.rrset as Buffer, proof.sig as Buffer),
-  )
-
-jest.setTimeout(10000)
-
-const wait = async (ms: number) =>
-  // eslint-disable-next-line no-promise-executor-return
-  new Promise((resolve) => setTimeout(resolve, ms))
-
-it('returns all rrsets when no proofs are known', async () => {
-  const result = await prepareDnsImport(publicClient, {
-    name: 'taytems.xyz',
-  })
-  expect(result.rrsets.length).toBeGreaterThan(0)
-  expect(result.proof).toBeInstanceOf(Uint8Array)
-  const decodedProofs = decodeProofs(result.rrsets)
-  const rootProofs = decodedProofs.filter((x) => x.signature.name === '.')
-  const tldProofs = decodedProofs.filter((x) => x.signature.name === 'xyz')
-  const twoLDProofs = decodedProofs.filter(
-    (x) => x.signature.name === 'taytems.xyz',
-  )
-  const threeLDProofs = decodedProofs.filter(
-    (x) => x.signature.name === '_ens.taytems.xyz',
-  )
-  expect(rootProofs.length).toBeGreaterThan(0)
-  expect(tldProofs.length).toBeGreaterThan(0)
-  expect(twoLDProofs.length).toBeGreaterThan(0)
-  expect(threeLDProofs.length).toBeGreaterThan(0)
-})
-it('returns rrsets up to the first unknown proof', async () => {
-  const tx = await importDnsName(walletClient, {
-    name: 'taytems.xyz',
-    account: accounts[0],
-    preparedData: await prepareDnsImport(publicClient, { name: 'taytems.xyz' }),
-  })
-  expect(tx).toBeTruthy()
-  const receipt = await waitForTransaction(tx)
-  expect(receipt.status).toBe('success')
-
-  await wait(5000)
-
-  const result = await prepareDnsImport(publicClient, {
-    name: 'lenster.xyz',
-  })
-  const decodedProofs = decodeProofs(result.rrsets)
-  const rootProofs = decodedProofs.filter((x) => x.signature.name === '.')
-  const tldProofs = decodedProofs.filter((x) => x.signature.name === 'xyz')
-  const twoLDProofs = decodedProofs.filter(
-    (x) => x.signature.name === 'lenster.xyz',
-  )
-  const threeLDProofs = decodedProofs.filter(
-    (x) => x.signature.name === '_ens.lenster.xyz',
-  )
-  expect(rootProofs).toHaveLength(0)
-  expect(tldProofs).toHaveLength(0)
-  expect(twoLDProofs.length).toBeGreaterThan(0)
-  expect(threeLDProofs.length).toBeGreaterThan(0)
-})
-it('returns empty rrsets for all known proofs when the last proof is known', async () => {
-  const tx = await importDnsName(walletClient, {
-    name: 'taytems.xyz',
-    account: accounts[0],
-    preparedData: await prepareDnsImport(publicClient, { name: 'taytems.xyz' }),
-  })
-  expect(tx).toBeTruthy()
-  const receipt = await waitForTransaction(tx)
-  expect(receipt.status).toBe('success')
-
-  await wait(5000)
-
-  const result = await prepareDnsImport(publicClient, {
-    name: 'taytems.xyz',
-  })
-  const decodedProofs = decodeProofs(result.rrsets)
-  const rootProofs = decodedProofs.filter((x) => x.signature.name === '.')
-  const tldProofs = decodedProofs.filter((x) => x.signature.name === 'xyz')
-  const twoLDProofs = decodedProofs.filter(
-    (x) => x.signature.name === 'taytems.xyz',
-  )
-  const threeLDProofs = decodedProofs.filter(
-    (x) => x.signature.name === '_ens.taytems.xyz',
-  )
-  expect(rootProofs).toHaveLength(0)
-  expect(tldProofs).toHaveLength(0)
-  expect(twoLDProofs).toHaveLength(0)
-  expect(threeLDProofs).toHaveLength(0)
-})

package/src/functions/public/batch.test.ts

@@ -1,67 +0,0 @@
-import { createPublicClient, http } from 'viem'
-import { mainnet } from 'viem/chains'
-import { addEnsContracts } from '../../contracts/addEnsContracts.js'
-import {
-  deploymentAddresses,
-  publicClient,
-} from '../../tests/addTestContracts.js'
-import batch from './batch.js'
-import getAddressRecord from './getAddressRecord.js'
-import getName from './getName.js'
-import getText from './getTextRecord.js'
-
-const mainnetPublicClient = createPublicClient({
-  chain: addEnsContracts(mainnet),
-  transport: http('https://web3.ens.domains/v1/mainnet'),
-})
-
-describe('batch', () => {
-  it('should batch calls together', async () => {
-    const result = await batch(
-      publicClient,
-      getText.batch({ name: 'with-profile.eth', key: 'description' }),
-      getAddressRecord.batch({ name: 'with-profile.eth' }),
-      getName.batch({ address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC' }),
-    )
-    expect(result).toMatchInlineSnapshot(`
-      [
-        "Hello2",
-        {
-          "id": 60,
-          "name": "ETH",
-          "value": "0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC",
-        },
-        {
-          "match": true,
-          "name": "with-profile.eth",
-          "resolverAddress": "${deploymentAddresses.LegacyPublicResolver}",
-          "reverseResolverAddress": "${deploymentAddresses.PublicResolver}",
-        },
-      ]
-    `)
-  })
-  it('should batch a single call', async () => {
-    const result = await batch(
-      publicClient,
-      getText.batch({ name: 'with-profile.eth', key: 'description' }),
-    )
-    expect(result).toMatchInlineSnapshot(`
-      [
-        "Hello2",
-      ]
-    `)
-  })
-  it('should batch ccip', async () => {
-    const result = await batch(
-      mainnetPublicClient,
-      getText.batch({ name: '1.offchainexample.eth', key: 'email' }),
-      getText.batch({ name: '2.offchainexample.eth', key: 'email' }),
-    )
-    expect(result).toMatchInlineSnapshot(`
-      [
-        "nick@ens.domains",
-        "nick@ens.domains",
-      ]
-    `)
-  })
-})

package/src/functions/public/ccip.test.ts

@@ -1,78 +0,0 @@
-import { createPublicClient, http } from 'viem'
-import { goerli } from 'viem/chains'
-import { addEnsContracts } from '../../contracts/addEnsContracts.js'
-import batch from './batch.js'
-import getAddressRecord from './getAddressRecord.js'
-import getRecords from './getRecords.js'
-import getText from './getTextRecord.js'
-
-const goerliPublicClient = createPublicClient({
-  chain: addEnsContracts(goerli),
-  transport: http('https://web3.ens.domains/v1/goerli'),
-})
-
-jest.setTimeout(30000)
-
-describe('CCIP', () => {
-  describe('getProfile', () => {
-    it('should return a profile from a ccip-read name', async () => {
-      const result = await getRecords(goerliPublicClient, {
-        name: '1.offchainexample.eth',
-        records: {
-          texts: ['email', 'description'],
-          contentHash: true,
-          coins: ['LTC', '60'],
-        },
-      })
-      if (!result) throw new Error('No result')
-      expect(result.coins.find((x) => x.name === 'ETH')!.value).toBe(
-        '0x41563129cDbbD0c5D3e1c86cf9563926b243834d',
-      )
-    })
-    it('should return a profile from arb-resolver.eth', async () => {
-      const result = await getRecords(goerliPublicClient, {
-        name: 'arb-resolver.eth',
-        records: {
-          texts: ['email', 'description'],
-          contentHash: true,
-          coins: ['LTC', '60'],
-        },
-      })
-      if (!result) throw new Error('No result')
-      expect(result.coins.find((x) => x.name === 'ETH')!.value).toBe(
-        '0xA5313060f9FA6B607AC8Ca8728a851166c9f6127',
-      )
-    })
-  })
-  describe('batch', () => {
-    it('allows batch ccip', async () => {
-      const result = await batch(
-        goerliPublicClient,
-        getAddressRecord.batch({ name: '1.offchainexample.eth' }),
-        getAddressRecord.batch({ name: '1.offchainexample.eth', coin: 'LTC' }),
-        getText.batch({ name: '1.offchainexample.eth', key: 'email' }),
-      )
-      if (!result) throw new Error('No result')
-      expect(result[0]!.value).toBe(
-        '0x41563129cDbbD0c5D3e1c86cf9563926b243834d',
-      )
-      expect(result[1]).toStrictEqual({
-        id: 2,
-        name: 'LTC',
-        value: 'MQMcJhpWHYVeQArcZR3sBgyPZxxRtnH441',
-      })
-      expect(result[2]).toBe('nick@ens.domains')
-      expect(result).toBeTruthy()
-    })
-    it('allows nested batch ccip', async () => {
-      const result = await batch(
-        goerliPublicClient,
-        batch.batch(getAddressRecord.batch({ name: '1.offchainexample.eth' })),
-      )
-      if (!result) throw new Error('No result')
-      expect(result[0]![0].value).toBe(
-        '0x41563129cDbbD0c5D3e1c86cf9563926b243834d',
-      )
-    })
-  })
-})

package/src/functions/public/getAbiRecord.test.ts

@@ -1,174 +0,0 @@
-import { publicClient } from '../../tests/addTestContracts.js'
-import getAbiRecord from './getAbiRecord.js'
-
-const dummyABI = [
-  {
-    type: 'event',
-    anonymous: false,
-    name: 'ABIChanged',
-    inputs: [
-      {
-        type: 'bytes32',
-        indexed: true,
-      },
-      {
-        type: 'uint256',
-        indexed: true,
-      },
-    ],
-  },
-  {
-    type: 'event',
-    anonymous: false,
-    name: 'VersionChanged',
-    inputs: [
-      {
-        type: 'bytes32',
-        indexed: true,
-      },
-      {
-        type: 'uint64',
-      },
-    ],
-  },
-  {
-    type: 'function',
-    name: 'ABI',
-    constant: true,
-    stateMutability: 'view',
-    payable: false,
-    inputs: [
-      {
-        type: 'bytes32',
-      },
-      {
-        type: 'uint256',
-      },
-    ],
-    outputs: [
-      {
-        type: 'uint256',
-      },
-      {
-        type: 'bytes',
-      },
-    ],
-  },
-  {
-    type: 'function',
-    name: 'clearRecords',
-    constant: false,
-    payable: false,
-    inputs: [
-      {
-        type: 'bytes32',
-      },
-    ],
-    outputs: [],
-  },
-  {
-    type: 'function',
-    name: 'recordVersions',
-    constant: true,
-    stateMutability: 'view',
-    payable: false,
-    inputs: [
-      {
-        type: 'bytes32',
-      },
-    ],
-    outputs: [
-      {
-        type: 'uint64',
-      },
-    ],
-  },
-  {
-    type: 'function',
-    name: 'setABI',
-    constant: false,
-    payable: false,
-    inputs: [
-      {
-        type: 'bytes32',
-      },
-      {
-        type: 'uint256',
-      },
-      {
-        type: 'bytes',
-      },
-    ],
-    outputs: [],
-  },
-  {
-    type: 'function',
-    name: 'supportsInterface',
-    constant: true,
-    stateMutability: 'view',
-    payable: false,
-    inputs: [
-      {
-        type: 'bytes4',
-      },
-    ],
-    outputs: [
-      {
-        type: 'bool',
-      },
-    ],
-  },
-]
-
-describe('getAbiRecord()', () => {
-  it('should return object for type 1 abi', async () => {
-    const result = await getAbiRecord(publicClient, {
-      name: 'with-type-1-abi.eth',
-    })
-    expect(result).toBeTruthy()
-    if (result) {
-      expect(result.contentType).toBe(1)
-      expect(result.decoded).toBe(true)
-      expect(result.abi).toMatchObject(dummyABI)
-    }
-  })
-  it('should return object for type 2 ABI', async () => {
-    const result = await getAbiRecord(publicClient, {
-      name: 'with-type-2-abi.eth',
-    })
-    expect(result).toBeTruthy()
-    if (result) {
-      expect(result.contentType).toBe(2)
-      expect(result.decoded).toBe(true)
-      expect(result.abi).toMatchObject(dummyABI)
-    }
-  })
-  it('should return object for type 4 ABI', async () => {
-    const result = await getAbiRecord(publicClient, {
-      name: 'with-type-4-abi.eth',
-    })
-    expect(result).toBeTruthy()
-    if (result) {
-      expect(result.contentType).toBe(4)
-      expect(result.decoded).toBe(true)
-      expect(result.abi).toMatchObject(dummyABI)
-    }
-  })
-  it('should return unresolved URI for type 8 ABI', async () => {
-    const result = await getAbiRecord(publicClient, {
-      name: 'with-type-8-abi.eth',
-    })
-    expect(result).toBeTruthy()
-    if (result) {
-      expect(result.contentType).toBe(8)
-      expect(result.decoded).toBe(true)
-      expect(result.abi).toBe('https://example.com')
-    }
-  })
-  it('should return undefined if unsupported contentType', async () => {
-    const result = await getAbiRecord(publicClient, {
-      name: 'with-type-256-abi.eth',
-    })
-    expect(result).toBeNull()
-  })
-})

package/src/functions/public/getAddressRecord.test.ts

@@ -1,83 +0,0 @@
-import { createPublicClient, http } from 'viem'
-import { mainnet } from 'viem/chains'
-import { addEnsContracts } from '../../contracts/addEnsContracts.js'
-import { publicClient } from '../../tests/addTestContracts.js'
-import getAddressRecord from './getAddressRecord.js'
-
-const mainnetPublicClient = createPublicClient({
-  chain: addEnsContracts(mainnet),
-  transport: http('https://web3.ens.domains/v1/mainnet'),
-})
-
-describe('getAddressRecord()', () => {
-  it('returns the ETH record when no coin is provided', async () => {
-    const result = await getAddressRecord(publicClient, {
-      name: 'with-profile.eth',
-    })
-    expect(result).toMatchInlineSnapshot(`
-      {
-        "id": 60,
-        "name": "ETH",
-        "value": "0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC",
-      }
-    `)
-  })
-  it('should return the correct address based on a coin ID input as a number', async () => {
-    const result = await getAddressRecord(publicClient, {
-      name: 'with-profile.eth',
-      coin: 61,
-    })
-    expect(result).toMatchInlineSnapshot(`
-      {
-        "id": 61,
-        "name": "ETC_LEGACY",
-        "value": "0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC",
-      }
-    `)
-  })
-  it('should return the correct address based on a coin ID input as a string', async () => {
-    const result = await getAddressRecord(publicClient, {
-      name: 'with-profile.eth',
-      coin: '61',
-    })
-    expect(result).toMatchInlineSnapshot(`
-      {
-        "id": 61,
-        "name": "ETC_LEGACY",
-        "value": "0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC",
-      }
-    `)
-  })
-  it('should return the correct address based on a coin name', async () => {
-    const result = await getAddressRecord(publicClient, {
-      name: 'with-profile.eth',
-      coin: 'ETC_LEGACY',
-    })
-    expect(result).toMatchInlineSnapshot(`
-      {
-        "id": 61,
-        "name": "ETC_LEGACY",
-        "value": "0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC",
-      }
-    `)
-  })
-  it('should return null for a non-existent coin', async () => {
-    const result = await getAddressRecord(publicClient, {
-      name: 'with-profile.eth',
-      coin: 'BNB',
-    })
-    expect(result).toBeNull()
-  })
-  it('should return value for label > 255 bytes', async () => {
-    const result = await getAddressRecord(mainnetPublicClient, {
-      name: `696969696969696969696969696969696969696969696969696969696969696969696969696969696969696969696969696969696969696969696969696969696969696969696969696969696969696969696969696969696969696969696969696969696969696969696969696969696969696969696969696969696969696969696969696969696969696969696969696969696969696969696969696969696969696969696969696969696969696969696969696969696969696969696969696969696969696969696969696969696969.eth`,
-    })
-    expect(result).toMatchInlineSnapshot(`
-      {
-        "id": 60,
-        "name": "ETH",
-        "value": "0xde9ba5F62D6047C4a9cCF24455AA733cCC5B8F41",
-      }
-    `)
-  })
-})

package/src/functions/public/getAvailable.test.ts

@@ -1,17 +0,0 @@
-import { publicClient } from '../../tests/addTestContracts.js'
-import getAvailable from './getAvailable.js'
-
-describe('getAvailable', () => {
-  it('should return false for a name that is unavailable', async () => {
-    const result = await getAvailable(publicClient, { name: 'test123.eth' })
-    expect(typeof result).toBe('boolean')
-    expect(result).toBe(false)
-  })
-  it('should return true for a name that is available', async () => {
-    const result = await getAvailable(publicClient, {
-      name: 'available-name.eth',
-    })
-    expect(typeof result).toBe('boolean')
-    expect(result).toBe(true)
-  })
-})

package/src/functions/public/getContentHashRecord.test.ts

@@ -1,28 +0,0 @@
-import { publicClient } from '../../tests/addTestContracts.js'
-import getContentHashRecord from './getContentHashRecord.js'
-
-describe('getContentHashRecord', () => {
-  it('should return null for a non-existent name', async () => {
-    const result = await getContentHashRecord(publicClient, {
-      name: 'test123123cool.eth',
-    })
-    expect(result).toBeNull()
-  })
-  it('should return null for a name with no contenthash record', async () => {
-    const result = await getContentHashRecord(publicClient, {
-      name: 'with-profile.eth',
-    })
-    expect(result).toBeNull()
-  })
-  it('should return the contenthash for a name with the record set', async () => {
-    const result = await getContentHashRecord(publicClient, {
-      name: 'with-contenthash.eth',
-    })
-    expect(result).toMatchInlineSnapshot(`
-      {
-        "decoded": "bafybeico3uuyj3vphxpvbowchdwjlrlrh62awxscrnii7w7flu5z6fk77y",
-        "protocolType": "ipfs",
-      }
-    `)
-  })
-})

package/src/functions/public/getExpiry.test.ts

@@ -1,48 +0,0 @@
-import { publicClient } from '../../tests/addTestContracts.js'
-import getExpiry from './getExpiry.js'
-
-describe('getExpiry', () => {
-  it('should get the expiry for a .eth name with no other args', async () => {
-    const result = await getExpiry(publicClient, { name: 'with-profile.eth' })
-    expect(result).toBeTruthy()
-    if (result) {
-      const { expiry, gracePeriod, status } = result
-      expect(expiry.date).toBeInstanceOf(Date)
-      expect(typeof expiry.value).toBe('bigint')
-      expect(gracePeriod).toBe(7776000)
-      expect(status).toBe('active')
-    }
-  })
-  it('should get the expiry for a wrapped name', async () => {
-    const result = await getExpiry(publicClient, {
-      name: 'wrapped.eth',
-      contract: 'nameWrapper',
-    })
-
-    expect(result).toBeTruthy()
-    if (result) {
-      const { expiry, gracePeriod, status } = result
-      expect(expiry.date).toBeInstanceOf(Date)
-      expect(typeof expiry.value).toBe('bigint')
-      expect(gracePeriod).toBe(0)
-      expect(status).toBe('active')
-    }
-  })
-  it('should return null for a non .eth name if not wrapped', async () => {
-    const result = await getExpiry(publicClient, {
-      name: 'sub.with-profile.eth',
-    })
-    expect(result).toBeNull()
-  })
-  it('should throw an error for a non .eth name if registrar is specified', async () => {
-    try {
-      await getExpiry(publicClient, {
-        name: 'sub.with-profile.eth',
-        contract: 'registrar',
-      })
-      expect(false).toBeTruthy()
-    } catch {
-      expect(true).toBeTruthy()
-    }
-  })
-})

package/src/functions/public/getName.test.ts

@@ -1,66 +0,0 @@
-import type { Address, Hex } from 'viem'
-import {
-  deploymentAddresses,
-  publicClient,
-  testClient,
-  waitForTransaction,
-  walletClient,
-} from '../../tests/addTestContracts.js'
-import setPrimaryName from '../wallet/setPrimaryName.js'
-import getName from './getName.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 })
-})
-
-describe('getName', () => {
-  it('should get a primary name from an address', async () => {
-    const result = await getName(publicClient, {
-      address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
-    })
-    expect(result).toMatchInlineSnapshot(`
-      {
-        "match": true,
-        "name": "with-profile.eth",
-        "resolverAddress": "${deploymentAddresses.LegacyPublicResolver}",
-        "reverseResolverAddress": "${deploymentAddresses.PublicResolver}",
-      }
-    `)
-  })
-  it('should return null for an address with no primary name', async () => {
-    const result = await getName(publicClient, {
-      address: '0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0',
-    })
-    expect(result).toBeNull()
-  })
-  it('should return with a false match for a name with no forward resolution', async () => {
-    const tx = await setPrimaryName(walletClient, {
-      name: 'with-profile.eth',
-      account: accounts[0],
-    })
-    await waitForTransaction(tx)
-
-    const result = await getName(publicClient, {
-      address: accounts[0],
-    })
-    expect(result).toMatchInlineSnapshot(`
-      {
-        "match": false,
-        "name": "with-profile.eth",
-        "resolverAddress": "${deploymentAddresses.LegacyPublicResolver}",
-        "reverseResolverAddress": "${deploymentAddresses.PublicResolver}",
-      }
-    `)
-  })
-})