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

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

@@ -1,69 +0,0 @@
-import type { Address, Hex } from 'viem'
-import {
-  publicClient,
-  testClient,
-  waitForTransaction,
-  walletClient,
-} from '../../tests/addTestContracts.js'
-import getContentHashRecord from '../public/getContentHashRecord.js'
-import getResolver from '../public/getResolver.js'
-import setContentHashRecord from './setContentHashRecord.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 a contenthash record to be set', async () => {
-  const tx = await setContentHashRecord(walletClient, {
-    name: 'test123.eth',
-    contentHash:
-      'ipns://k51qzi5uqu5dgox2z23r6e99oqency055a6xt92xzmyvpz8mwz5ycjavm0u150',
-    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 getContentHashRecord(publicClient, {
-    name: 'test123.eth',
-  })
-  expect(response).toMatchInlineSnapshot(`
-    {
-      "decoded": "k51qzi5uqu5dgox2z23r6e99oqency055a6xt92xzmyvpz8mwz5ycjavm0u150",
-      "protocolType": "ipns",
-    }
-  `)
-})
-
-it('should allow a contenthash record to be set to blank', async () => {
-  const tx = await setContentHashRecord(walletClient, {
-    name: 'with-contenthash.eth',
-    contentHash: 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 getContentHashRecord(publicClient, {
-    name: 'test123.eth',
-  })
-  expect(response).toBeNull()
-})

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

@@ -1,287 +0,0 @@
-import type { Address, Hex } from 'viem'
-import { getChainContractAddress } from '../../contracts/getChainContractAddress.js'
-import { nameWrapperGetDataSnippet } from '../../contracts/nameWrapper.js'
-import { getVersion } from '../../errors/error-utils.js'
-import {
-  publicClient,
-  testClient,
-  waitForTransaction,
-  walletClient,
-} from '../../tests/addTestContracts.js'
-import {
-  unnamedUserSettableFuses,
-  userSettableFuseEnum,
-} from '../../utils/fuses.js'
-import { namehash } from '../../utils/normalise.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 checkUnnamedFuses = (
-  fuses: number,
-  expected: (keyof typeof unnamedUserSettableFuses)[],
-) => {
-  // eslint-disable-next-line guard-for-in
-  for (const fuse of unnamedUserSettableFuses) {
-    const active = (fuses & fuse) > 0
-    if (expected.includes(fuse as keyof typeof unnamedUserSettableFuses)) {
-      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
-}
-
-describe('Array', () => {
-  it('should return a setFuses transaction from a named fuse array and succeed', async () => {
-    const tx = await setFuses(walletClient, {
-      name: 'wrapped.eth',
-      fuses: {
-        named: [
-          'CANNOT_UNWRAP',
-          'CANNOT_CREATE_SUBDOMAIN',
-          'CANNOT_SET_TTL',
-          'CANNOT_APPROVE',
-        ],
-      },
-      account: accounts[1],
-    })
-    const receipt = await waitForTransaction(tx)
-    expect(receipt.status).toBe('success')
-
-    const fuses = await getFuses('wrapped.eth')
-    checkFuses(fuses, [
-      'CANNOT_UNWRAP',
-      'CANNOT_CREATE_SUBDOMAIN',
-      'CANNOT_SET_TTL',
-      'PARENT_CANNOT_CONTROL',
-      'CANNOT_APPROVE',
-    ])
-  })
-  it('should return a setFuses transaction from an unnamed fuse array and succeed', async () => {
-    const tx0 = await setFuses(walletClient, {
-      name: 'wrapped.eth',
-      fuses: {
-        named: ['CANNOT_UNWRAP'],
-      },
-      account: accounts[1],
-    })
-    const tx0Receipt = await waitForTransaction(tx0)
-    expect(tx0Receipt.status).toBe('success')
-
-    const tx = await setFuses(walletClient, {
-      name: 'wrapped.eth',
-      fuses: {
-        unnamed: [128, 256, 512],
-      },
-      account: accounts[1],
-    })
-    const receipt = await waitForTransaction(tx)
-    expect(receipt.status).toBe('success')
-
-    const fuses = await getFuses('wrapped.eth')
-    checkUnnamedFuses(fuses, [128, 256, 512])
-  })
-  it('should return a setFuses transaction from both an unnamed and named fuse array and succeed', async () => {
-    const tx = await setFuses(walletClient, {
-      name: 'wrapped.eth',
-      fuses: {
-        named: [
-          'CANNOT_UNWRAP',
-          'CANNOT_CREATE_SUBDOMAIN',
-          'CANNOT_SET_TTL',
-          'CANNOT_APPROVE',
-        ],
-        unnamed: [128, 256, 512],
-      },
-      account: accounts[1],
-    })
-    const receipt = await waitForTransaction(tx)
-    expect(receipt.status).toBe('success')
-
-    const fuses = await getFuses('wrapped.eth')
-    checkFuses(fuses, [
-      'CANNOT_UNWRAP',
-      'CANNOT_CREATE_SUBDOMAIN',
-      'CANNOT_SET_TTL',
-      'PARENT_CANNOT_CONTROL',
-      'CANNOT_APPROVE',
-    ])
-    checkUnnamedFuses(fuses, [128, 256, 512])
-  })
-  it('should throw an error when trying to burn a named fuse in an unnamed fuse array', async () => {
-    await expect(
-      setFuses(walletClient, {
-        name: 'wrapped.eth',
-        fuses: {
-          unnamed: [32] as any,
-        },
-
-        account: accounts[1],
-      }),
-    ).rejects.toThrowErrorMatchingInlineSnapshot(`
-      "32 is not a valid unnamed fuse
-
-      - If you are trying to set a named fuse, use the named property
-
-      Version: ${getVersion()}"
-    `)
-  })
-  it('should throw an error when trying to burn an unnamed fuse in a named fuse array', async () => {
-    await expect(
-      setFuses(walletClient, {
-        name: 'wrapped.eth',
-        fuses: {
-          named: ['COOL_SWAG_FUSE'] as any,
-        },
-      }),
-    ).rejects.toThrowErrorMatchingInlineSnapshot(`
-      "COOL_SWAG_FUSE is not a valid named fuse
-
-      Version: ${getVersion()}"
-    `)
-  })
-})
-describe('Number', () => {
-  it('should return a setFuses transaction from a number and succeed', async () => {
-    const tx = await setFuses(walletClient, {
-      name: 'wrapped.eth',
-      fuses: {
-        number: 113,
-      },
-      account: accounts[1],
-    })
-    expect(tx).toBeTruthy()
-    const receipt = await waitForTransaction(tx)
-    expect(receipt.status).toBe('success')
-
-    const fuses = await getFuses('wrapped.eth')
-    checkFuses(fuses, [
-      'CANNOT_UNWRAP',
-      'CANNOT_CREATE_SUBDOMAIN',
-      'CANNOT_SET_TTL',
-      'CANNOT_APPROVE',
-      'PARENT_CANNOT_CONTROL',
-    ])
-  })
-  it('should throw an error if the number is too high', async () => {
-    await expect(
-      setFuses(walletClient, {
-        name: 'wrapped.eth',
-        fuses: {
-          number: 4294967297,
-        },
-
-        account: accounts[1],
-      }),
-    ).rejects.toThrowErrorMatchingInlineSnapshot(`
-      "Fuse value out of range
-
-      - Fuse value: 4294967297
-      - Allowed range: 1-4294967296
-
-      Details: Fuse number must be limited to uint32, the supplied value was too high
-
-      Version: ${getVersion()}"
-    `)
-  })
-  it('should throw an error if the number is too low', async () => {
-    await expect(
-      setFuses(walletClient, {
-        name: 'wrapped.eth',
-        fuses: {
-          number: -1,
-        },
-
-        account: accounts[1],
-      }),
-    ).rejects.toThrowErrorMatchingInlineSnapshot(`
-      "Fuse value out of range
-
-      - Fuse value: -1
-      - Allowed range: 1-4294967296
-
-      Details: Fuse number must be limited to uint32, the supplied value was too low
-
-      Version: ${getVersion()}"
-    `)
-  })
-  it('should throw an error if the number is not an integer', async () => {
-    await expect(
-      setFuses(walletClient, {
-        name: 'wrapped.eth',
-        fuses: {
-          number: 7.5,
-        },
-
-        account: accounts[1],
-      }),
-    ).rejects.toThrowErrorMatchingInlineSnapshot(`
-      "Fuse was not an integer, which is required
-
-      - Fuse value: 7.5
-
-      Version: ${getVersion()}"
-    `)
-  })
-})

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

@@ -1,71 +0,0 @@
-import type { Address, Hex } from 'viem'
-import { getChainContractAddress } from '../../contracts/getChainContractAddress.js'
-import { registrySetApprovalForAllSnippet } from '../../contracts/registry.js'
-import {
-  publicClient,
-  testClient,
-  waitForTransaction,
-  walletClient,
-} from '../../tests/addTestContracts.js'
-import getName from '../public/getName.js'
-import setPrimaryName from './setPrimaryName.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 return a transaction for a name and set successfully', async () => {
-  const tx = await setPrimaryName(walletClient, {
-    name: 'test123.eth',
-    account: accounts[1],
-  })
-  expect(tx).toBeTruthy()
-  const receipt = await waitForTransaction(tx)
-  expect(receipt.status).toBe('success')
-
-  const resolvedName = await getName(publicClient, {
-    address: accounts[1],
-  })
-  expect(resolvedName!.name).toBe('test123.eth')
-})
-
-it("should return a transaction for setting another address' name and succeed", async () => {
-  const setApprovedForAllTx = await walletClient.writeContract({
-    abi: registrySetApprovalForAllSnippet,
-    functionName: 'setApprovalForAll',
-    address: getChainContractAddress({
-      client: walletClient,
-      contract: 'ensRegistry',
-    }),
-    args: [accounts[2], true],
-    account: accounts[1],
-  })
-  expect(setApprovedForAllTx).toBeTruthy()
-  const setApprovedForAllReceipt = await waitForTransaction(setApprovedForAllTx)
-  expect(setApprovedForAllReceipt.status).toBe('success')
-
-  const tx = await setPrimaryName(walletClient, {
-    name: 'test123.eth',
-    address: accounts[1],
-    account: accounts[2],
-  })
-  expect(tx).toBeTruthy()
-  const receipt = await waitForTransaction(tx)
-  expect(receipt.status).toBe('success')
-
-  const resolvedName = await getName(publicClient, {
-    address: accounts[1],
-  })
-  expect(resolvedName!.name).toBe('test123.eth')
-})

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

@@ -1,127 +0,0 @@
-import type { Address, Hex } from 'viem'
-import { getVersion } from '../../errors/error-utils.js'
-import {
-  publicClient,
-  testClient,
-  waitForTransaction,
-  walletClient,
-} from '../../tests/addTestContracts.js'
-import { encodeAbi } from '../../utils/encoders/encodeAbi.js'
-import getRecords from '../public/getRecords.js'
-import getResolver from '../public/getResolver.js'
-import setRecords from './setRecords.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 return a transaction to the resolver and set successfully', async () => {
-  const tx = await setRecords(walletClient, {
-    name: 'test123.eth',
-    resolverAddress: (await getResolver(publicClient, {
-      name: 'test123.eth',
-    }))!,
-    coins: [
-      {
-        coin: 'ETC_LEGACY',
-        value: '0x42D63ae25990889E35F215bC95884039Ba354115',
-      },
-    ],
-    texts: [{ key: 'foo', value: 'bar' }],
-    abi: await encodeAbi({ encodeAs: 'json', data: dummyABI }),
-    account: accounts[1],
-  })
-  expect(tx).toBeTruthy()
-  const receipt = await waitForTransaction(tx)
-  expect(receipt.status).toBe('success')
-
-  const records = await getRecords(publicClient, {
-    name: 'test123.eth',
-    records: {
-      coins: ['ETC_LEGACY'],
-      texts: ['foo'],
-      abi: true,
-    },
-  })
-  expect(records.abi!.abi).toStrictEqual(dummyABI)
-  expect(records.coins).toMatchInlineSnapshot(`
-    [
-      {
-        "id": 61,
-        "name": "ETC_LEGACY",
-        "value": "0x42D63ae25990889E35F215bC95884039Ba354115",
-      },
-    ]
-  `)
-  expect(records.texts).toMatchInlineSnapshot(`
-    [
-      {
-        "key": "foo",
-        "value": "bar",
-      },
-    ]
-  `)
-})
-it('should error if there are no records to set', async () => {
-  await expect(
-    setRecords(walletClient, {
-      name: 'test123.eth',
-      resolverAddress: (await getResolver(publicClient, {
-        name: 'test123.eth',
-      }))!,
-
-      account: accounts[1],
-    }),
-  ).rejects.toThrowErrorMatchingInlineSnapshot(`
-    "No records specified
-
-    Version: ${getVersion()}"
-  `)
-})
-it('should not wrap with multicall if only setting a single record', async () => {
-  const encodedData = setRecords.makeFunctionData(walletClient, {
-    name: 'test123.eth',
-    resolverAddress: (await getResolver(publicClient, {
-      name: 'test123.eth',
-    }))!,
-    coins: [
-      {
-        coin: 'ETC_LEGACY',
-        value: '0x42D63ae25990889E35F215bC95884039Ba354115',
-      },
-    ],
-  })
-  // 0x8b95dd71 is the function selector for setAddr(bytes32,uint256,bytes)
-  expect(encodedData.data.startsWith('0x8b95dd71')).toBe(true)
-})

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

@@ -1,114 +0,0 @@
-import type { Address, Hex } from 'viem'
-import {
-  publicClient,
-  testClient,
-  waitForTransaction,
-  walletClient,
-} from '../../tests/addTestContracts.js'
-import getResolver from '../public/getResolver.js'
-import setResolver from './setResolver.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 return a setResolver transaction to the registry and succeed', async () => {
-  const tx = await setResolver(walletClient, {
-    name: 'test123.eth',
-    contract: 'registry',
-    resolverAddress: '0xAEfF4f4d8e2cB51854BEa2244B3C5Fb36b41C7fC',
-    account: accounts[1],
-  })
-  expect(tx).toBeTruthy()
-  const receipt = await waitForTransaction(tx)
-  expect(receipt.status).toBe('success')
-
-  const resolver = await getResolver(publicClient, {
-    name: 'test123.eth',
-  })
-  expect(resolver).toBe('0xAEfF4f4d8e2cB51854BEa2244B3C5Fb36b41C7fC')
-})
-it('should return a setResolver transaction to the namewrapper and succeed', async () => {
-  const tx = await setResolver(walletClient, {
-    name: 'wrapped.eth',
-    contract: 'nameWrapper',
-    resolverAddress: '0xAEfF4f4d8e2cB51854BEa2244B3C5Fb36b41C7fC',
-    account: accounts[1],
-  })
-  expect(tx).toBeTruthy()
-  const receipt = await waitForTransaction(tx)
-  expect(receipt.status).toBe('success')
-
-  const resolver = await getResolver(publicClient, {
-    name: 'wrapped.eth',
-  })
-  expect(resolver).toBe('0xAEfF4f4d8e2cB51854BEa2244B3C5Fb36b41C7fC')
-})
-it('should error if unknown contract', async () => {
-  await expect(
-    setResolver(walletClient, {
-      name: 'test123.eth',
-      contract: 'random' as any,
-      resolverAddress: '0xAEfF4f4d8e2cB51854BEa2244B3C5Fb36b41C7fC',
-      account: accounts[1],
-    }),
-  ).rejects.toThrow('Unknown contract: random')
-})
-
-// it('should return a transaction for a name and set successfully', async () => {
-//   const tx = await setName(walletClient, {
-//     name: 'test123.eth',
-//     account: accounts[1],
-//   })
-//   expect(tx).toBeTruthy()
-//   const receipt = await publicClient.waitForTransactionReceipt({ hash: tx })
-//   expect(receipt.status).toBe('success')
-
-//   const resolvedName = await getName(publicClient, {
-//     address: accounts[1],
-//   })
-//   expect(resolvedName!.name).toBe('test123.eth')
-// })
-
-// it("should return a transaction for setting another address' name and succeed", async () => {
-//   const setApprovedForAllTx = await walletClient.writeContract({
-//     abi: setApprovalForAllSnippet,
-//     functionName: 'setApprovalForAll',
-//     address: getChainContractAddress({
-//       client: walletClient,
-//       contract: 'ensRegistry',
-//     }),
-//     args: [accounts[2], true],
-//     account: accounts[1],
-//   })
-//   expect(setApprovedForAllTx).toBeTruthy()
-//   const setApprovedForAllReceipt = await publicClient.waitForTransactionReceipt(
-//     { hash: setApprovedForAllTx },
-//   )
-//   expect(setApprovedForAllReceipt.status).toBe('success')
-
-//   const tx = await setName(walletClient, {
-//     name: 'test123.eth',
-//     address: accounts[1],
-//     account: accounts[2],
-//   })
-//   expect(tx).toBeTruthy()
-//   const receipt = await publicClient.waitForTransactionReceipt({ hash: tx })
-//   expect(receipt.status).toBe('success')
-
-//   const resolvedName = await getName(publicClient, {
-//     address: accounts[1],
-//   })
-//   expect(resolvedName!.name).toBe('test123.eth')
-// })