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

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

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

@@ -1,156 +0,0 @@
-import type { Address, Hex } from 'viem'
-import {
-  publicClient,
-  testClient,
-  waitForTransaction,
-  walletClient,
-} from '../../tests/addTestContracts.js'
-import { encodeAbi } from '../../utils/encoders/encodeAbi.js'
-import getAbiRecord from '../public/getAbiRecord.js'
-import getResolver from '../public/getResolver.js'
-import setAbiRecord from './setAbiRecord.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 dummyABI = [
-  {
-    type: 'function',
-    name: 'supportsInterface',
-    constant: true,
-    stateMutability: 'view',
-    payable: false,
-    inputs: [
-      {
-        type: 'bytes4',
-      },
-    ],
-    outputs: [
-      {
-        type: 'bool',
-      },
-    ],
-  },
-]
-
-it('should allow an abi record to be set with json content type', async () => {
-  const encodedAbi = await encodeAbi({ encodeAs: 'json', data: dummyABI })
-  const tx = await setAbiRecord(walletClient, {
-    name: 'test123.eth',
-    encodedAbi,
-    resolverAddress: (await getResolver(publicClient, {
-      name: 'test123.eth',
-    }))!,
-    account: accounts[1],
-  })
-  expect(tx).toBeTruthy()
-  const receipt = await waitForTransaction(tx)
-  expect(receipt.status).toBe('success')
-
-  const response = await getAbiRecord(publicClient, {
-    name: 'test123.eth',
-  })
-  expect(response!.abi).toEqual(dummyABI)
-  expect(response!.contentType).toEqual(1)
-  expect(response!.decoded).toBe(true)
-})
-
-it('should allow an abi record to be set with zlib content type', async () => {
-  const encodedAbi = await encodeAbi({ encodeAs: 'zlib', data: dummyABI })
-  const tx = await setAbiRecord(walletClient, {
-    name: 'test123.eth',
-    encodedAbi,
-    resolverAddress: (await getResolver(publicClient, {
-      name: 'test123.eth',
-    }))!,
-    account: accounts[1],
-  })
-  expect(tx).toBeTruthy()
-  const receipt = await waitForTransaction(tx)
-  expect(receipt.status).toBe('success')
-
-  const response = await getAbiRecord(publicClient, {
-    name: 'test123.eth',
-  })
-  expect(response!.abi).toEqual(dummyABI)
-  expect(response!.contentType).toEqual(2)
-  expect(response!.decoded).toBe(true)
-})
-
-it('should allow an abi record to be set with cbor content type', async () => {
-  const encodedAbi = await encodeAbi({ encodeAs: 'cbor', data: dummyABI })
-  const tx = await setAbiRecord(walletClient, {
-    name: 'test123.eth',
-    encodedAbi,
-    resolverAddress: (await getResolver(publicClient, {
-      name: 'test123.eth',
-    }))!,
-    account: accounts[1],
-  })
-  expect(tx).toBeTruthy()
-  const receipt = await waitForTransaction(tx)
-  expect(receipt.status).toBe('success')
-
-  const response = await getAbiRecord(publicClient, {
-    name: 'test123.eth',
-  })
-  expect(response!.abi).toEqual(dummyABI)
-  expect(response!.contentType).toEqual(4)
-  expect(response!.decoded).toBe(true)
-})
-
-it('should allow an abi record to be set with uri content type', async () => {
-  const encodedAbi = await encodeAbi({
-    encodeAs: 'uri',
-    data: 'https://example.com',
-  })
-  const tx = await setAbiRecord(walletClient, {
-    name: 'test123.eth',
-    encodedAbi,
-    resolverAddress: (await getResolver(publicClient, {
-      name: 'test123.eth',
-    }))!,
-    account: accounts[1],
-  })
-  expect(tx).toBeTruthy()
-  const receipt = await waitForTransaction(tx)
-  expect(receipt.status).toBe('success')
-
-  const response = await getAbiRecord(publicClient, {
-    name: 'test123.eth',
-  })
-  expect(response!.abi).toEqual('https://example.com')
-  expect(response!.contentType).toEqual(8)
-  expect(response!.decoded).toBe(true)
-})
-
-it('should allow an abi record to be set to blank', async () => {
-  const tx = await setAbiRecord(walletClient, {
-    name: 'with-type-1-abi.eth',
-    encodedAbi: null,
-    resolverAddress: (await getResolver(publicClient, {
-      name: 'test123.eth',
-    }))!,
-    account: accounts[1],
-  })
-  expect(tx).toBeTruthy()
-  const receipt = await waitForTransaction(tx)
-  expect(receipt.status).toBe('success')
-
-  const response = await getAbiRecord(publicClient, {
-    name: 'test123.eth',
-  })
-  expect(response).toBeNull()
-})

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

@@ -1,121 +0,0 @@
-import type { Address, Hex } from 'viem'
-import {
-  publicClient,
-  testClient,
-  waitForTransaction,
-  walletClient,
-} from '../../tests/addTestContracts.js'
-import getAddressRecord from '../public/getAddressRecord.js'
-import getResolver from '../public/getResolver.js'
-import setAddressRecord from './setAddressRecord.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 an eth address record to be set', async () => {
-  const tx = await setAddressRecord(walletClient, {
-    name: 'test123.eth',
-    coin: 'ETH',
-    value: '0x42D63ae25990889E35F215bC95884039Ba354115',
-    resolverAddress: (await getResolver(publicClient, {
-      name: 'test123.eth',
-    }))!,
-    account: accounts[1],
-  })
-  expect(tx).toBeTruthy()
-  const receipt = await waitForTransaction(tx)
-  expect(receipt.status).toBe('success')
-
-  const response = await getAddressRecord(publicClient, {
-    name: 'test123.eth',
-    coin: 'ETH',
-  })
-  expect(response).toMatchInlineSnapshot(`
-    {
-      "id": 60,
-      "name": "ETH",
-      "value": "0x42D63ae25990889E35F215bC95884039Ba354115",
-    }
-  `)
-})
-
-it('should allow a multicoin address record to be set', async () => {
-  const tx = await setAddressRecord(walletClient, {
-    name: 'test123.eth',
-    coin: 'ETC_LEGACY',
-    value: '0x42D63ae25990889E35F215bC95884039Ba354115',
-    resolverAddress: (await getResolver(publicClient, {
-      name: 'test123.eth',
-    }))!,
-    account: accounts[1],
-  })
-  expect(tx).toBeTruthy()
-  const receipt = await waitForTransaction(tx)
-  expect(receipt.status).toBe('success')
-
-  const response = await getAddressRecord(publicClient, {
-    name: 'test123.eth',
-    coin: 'ETC_LEGACY',
-  })
-  expect(response).toMatchInlineSnapshot(`
-    {
-      "id": 61,
-      "name": "ETC_LEGACY",
-      "value": "0x42D63ae25990889E35F215bC95884039Ba354115",
-    }
-  `)
-})
-
-it('should allow an eth record to be set to blank', async () => {
-  const tx = await setAddressRecord(walletClient, {
-    name: 'test123.eth',
-    coin: 'ETH',
-    value: null,
-    resolverAddress: (await getResolver(publicClient, {
-      name: 'test123.eth',
-    }))!,
-    account: accounts[1],
-  })
-  expect(tx).toBeTruthy()
-  const receipt = await waitForTransaction(tx)
-  expect(receipt.status).toBe('success')
-
-  const response = await getAddressRecord(publicClient, {
-    name: 'test123.eth',
-    coin: 'ETH',
-  })
-  expect(response).toBeNull()
-})
-
-it('should allow a multicoin record to be set to blank', async () => {
-  const tx = await setAddressRecord(walletClient, {
-    name: 'with-profile.eth',
-    coin: 'BTC',
-    value: null,
-    resolverAddress: (await getResolver(publicClient, {
-      name: 'with-profile.eth',
-    }))!,
-    account: accounts[2],
-  })
-  expect(tx).toBeTruthy()
-  const receipt = await waitForTransaction(tx)
-  expect(receipt.status).toBe('success')
-
-  const response = await getAddressRecord(publicClient, {
-    name: 'with-profile.eth',
-    coin: 'BTC',
-  })
-  expect(response).toBeNull()
-})

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

@@ -1,97 +0,0 @@
-import type { Address, Hex } from 'viem'
-import { getChainContractAddress } from '../../contracts/getChainContractAddress.js'
-import { nameWrapperGetDataSnippet } from '../../contracts/nameWrapper.js'
-import {
-  publicClient,
-  testClient,
-  waitForTransaction,
-  walletClient,
-} from '../../tests/addTestContracts.js'
-import { userSettableFuseEnum } from '../../utils/fuses.js'
-import { namehash } from '../../utils/normalise.js'
-import setChildFuses from './setChildFuses.js'
-import setFuses from './setFuses.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 checkFuses = (
-  fuses: number,
-  expected: (keyof typeof userSettableFuseEnum)[],
-) => {
-  // eslint-disable-next-line guard-for-in
-  for (const fuse in userSettableFuseEnum) {
-    const active =
-      (fuses &
-        userSettableFuseEnum[fuse as keyof typeof userSettableFuseEnum]) >
-      0
-    if (expected.includes(fuse as keyof typeof userSettableFuseEnum)) {
-      try {
-        expect(active).toBeTruthy()
-      } catch {
-        throw new Error(`${fuse} should be true but is false`)
-      }
-    } else if (active) {
-      try {
-        expect(active).toBeFalsy()
-      } catch {
-        throw new Error(`${fuse} should be false but is true`)
-      }
-    }
-  }
-}
-
-const getFuses = async (name: string) => {
-  const [, fuses] = await publicClient.readContract({
-    abi: nameWrapperGetDataSnippet,
-    address: getChainContractAddress({
-      client: publicClient,
-      contract: 'ensNameWrapper',
-    }),
-    functionName: 'getData',
-    args: [BigInt(namehash(name))],
-  })
-  return fuses
-}
-
-it('should return a setChildFuses transaction and succeed', async () => {
-  const setParentTx = await setFuses(walletClient, {
-    name: 'wrapped-with-subnames.eth',
-    fuses: {
-      named: ['CANNOT_UNWRAP'],
-    },
-    account: accounts[1],
-  })
-  expect(setParentTx).toBeTruthy()
-  const setParentTxReceipt = await waitForTransaction(setParentTx)
-  expect(setParentTxReceipt.status).toBe('success')
-
-  const tx = await setChildFuses(walletClient, {
-    name: 'test.wrapped-with-subnames.eth',
-    fuses: 65537 + 64,
-    account: accounts[1],
-  })
-  expect(tx).toBeTruthy()
-  const receipt = await waitForTransaction(tx)
-  expect(receipt.status).toBe('success')
-
-  const fuses = await getFuses('test.wrapped-with-subnames.eth')
-
-  checkFuses(fuses, [
-    'CANNOT_UNWRAP',
-    'PARENT_CANNOT_CONTROL',
-    'CANNOT_APPROVE',
-  ])
-})