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

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

@@ -1,67 +0,0 @@
-import type { Address, Hex } from 'viem'
-import {
-  publicClient,
-  testClient,
-  waitForTransaction,
-  walletClient,
-} from '../../tests/addTestContracts.js'
-import getResolver from '../public/getResolver.js'
-import getText from '../public/getTextRecord.js'
-import setTextRecord from './setTextRecord.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 text record to be set', async () => {
-  const tx = await setTextRecord(walletClient, {
-    name: 'test123.eth',
-    key: 'foo',
-    value: 'bar',
-    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 getText(publicClient, {
-    name: 'test123.eth',
-    key: 'foo',
-  })
-  expect(response).toBe('bar')
-})
-
-it('should allow a text record to be set to blank', async () => {
-  const tx = await setTextRecord(walletClient, {
-    name: 'test123.eth',
-    key: 'url',
-    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 getText(publicClient, {
-    name: 'test123.eth',
-    key: 'url',
-  })
-  expect(response).toBeNull()
-})

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

@@ -1,201 +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 getOwner from '../public/getOwner.js'
-import transferName from './transferName.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 transfer on the registry', async () => {
-  const tx = await transferName(walletClient, {
-    name: 'test.with-subnames.eth',
-    newOwnerAddress: accounts[1],
-    contract: 'registry',
-    account: accounts[2],
-  })
-  expect(tx).toBeTruthy()
-  const receipt = await waitForTransaction(tx)
-  expect(receipt.status).toBe('success')
-
-  const owner = await getOwner(publicClient, {
-    name: 'test.with-subnames.eth',
-    contract: 'registry',
-  })
-
-  expect(owner!.owner).toBe(accounts[1])
-})
-it('should allow a regular transfer on the registrar', async () => {
-  const tx = await transferName(walletClient, {
-    name: 'test123.eth',
-    newOwnerAddress: accounts[2],
-    contract: 'registrar',
-    account: accounts[1],
-  })
-  expect(tx).toBeTruthy()
-  const receipt = await waitForTransaction(tx)
-  expect(receipt.status).toBe('success')
-
-  const owner = await getOwner(publicClient, {
-    name: 'test123.eth',
-    contract: 'registrar',
-  })
-  expect(owner!.registrant).toBe(accounts[2])
-})
-it('should allow a reclaim on the registrar', async () => {
-  const changeRegistryOwnerTx = await transferName(walletClient, {
-    name: 'test123.eth',
-    newOwnerAddress: accounts[2],
-    contract: 'registry',
-    account: accounts[1],
-  })
-  expect(changeRegistryOwnerTx).toBeTruthy()
-  const changeRegistryOwnerReceipt = await waitForTransaction(
-    changeRegistryOwnerTx,
-  )
-  expect(changeRegistryOwnerReceipt.status).toBe('success')
-
-  const tx = await transferName(walletClient, {
-    name: 'test123.eth',
-    newOwnerAddress: accounts[1],
-    contract: 'registrar',
-    reclaim: true,
-    account: accounts[1],
-  })
-  expect(tx).toBeTruthy()
-  const receipt = await waitForTransaction(tx)
-  expect(receipt.status).toBe('success')
-
-  const owner = await getOwner(publicClient, {
-    name: 'test123.eth',
-    contract: 'registry',
-  })
-  expect(owner!.owner).toBe(accounts[1])
-})
-it('should allow a transfer on the namewrapper', async () => {
-  const tx = await transferName(walletClient, {
-    name: 'wrapped.eth',
-    newOwnerAddress: accounts[2],
-    contract: 'nameWrapper',
-    account: accounts[1],
-  })
-  expect(tx).toBeTruthy()
-  const receipt = await waitForTransaction(tx)
-  expect(receipt.status).toBe('success')
-
-  const owner = await getOwner(publicClient, {
-    name: 'wrapped.eth',
-    contract: 'nameWrapper',
-  })
-  expect(owner!.owner).toBe(accounts[2])
-})
-it('errors if unknown contract', async () => {
-  await expect(
-    transferName(walletClient, {
-      name: 'test123.eth',
-      newOwnerAddress: accounts[2],
-      contract: 'random' as any,
-      account: accounts[1],
-    }),
-  ).rejects.toThrowErrorMatchingInlineSnapshot(`
-    "Invalid contract type: random
-
-    - Supported contract types: registry, registrar, nameWrapper
-
-    Version: ${getVersion()}"
-  `)
-})
-it('errors when reclaim is specified and contract is not registrar', async () => {
-  await expect(
-    transferName(walletClient, {
-      name: 'test123.eth',
-      newOwnerAddress: accounts[2],
-      contract: 'registry',
-      reclaim: true,
-      account: accounts[1],
-    } as any),
-  ).rejects.toThrowErrorMatchingInlineSnapshot(`
-    "Additional parameter specified: reclaim
-
-    - Allowed parameters: name, newOwnerAddress, contract
-
-    Details: Can't reclaim a name from any contract other than the registrar
-
-    Version: ${getVersion()}"
-  `)
-})
-
-describe('subnames/asParent', () => {
-  it('allows transferring a subname on the registry', async () => {
-    const tx = await transferName(walletClient, {
-      name: 'test.with-subnames.eth',
-      contract: 'registry',
-      newOwnerAddress: accounts[1],
-      asParent: true,
-      account: accounts[1],
-    })
-    expect(tx).toBeTruthy()
-    const receipt = await waitForTransaction(tx)
-    expect(receipt.status).toBe('success')
-
-    const owner = await getOwner(publicClient, {
-      name: 'test.with-subnames.eth',
-      contract: 'registry',
-    })
-    expect(owner!.owner).toBe(accounts[1])
-  })
-  it('allows transferring a subname on the namewrapper', async () => {
-    const tx = await transferName(walletClient, {
-      name: 'test.wrapped-with-subnames.eth',
-      contract: 'nameWrapper',
-      newOwnerAddress: accounts[1],
-      asParent: true,
-      account: accounts[1],
-    })
-    expect(tx).toBeTruthy()
-    const receipt = await waitForTransaction(tx)
-    expect(receipt.status).toBe('success')
-
-    const owner = await getOwner(publicClient, {
-      name: 'test.wrapped-with-subnames.eth',
-      contract: 'nameWrapper',
-    })
-    expect(owner!.owner).toBe(accounts[1])
-  })
-  it('erorrs when asParent is specified and contract is registrar', async () => {
-    await expect(
-      transferName(walletClient, {
-        name: 'test123.eth',
-        newOwnerAddress: accounts[2],
-        contract: 'registrar',
-        asParent: true,
-        account: accounts[1],
-      } as any),
-    ).rejects.toThrowErrorMatchingInlineSnapshot(`
-      "Additional parameter specified: asParent
-
-      - Allowed parameters: name, newOwnerAddress, contract, reclaim
-
-      Details: Can't transfer a name as the parent owner on the registrar
-
-      Version: ${getVersion()}"
-    `)
-  })
-})

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

@@ -1,93 +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 getOwner from '../public/getOwner.js'
-import unwrapName from './unwrapName.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 .eth unwrap name transaction and succeed', async () => {
-  const tx = await unwrapName(walletClient, {
-    name: 'wrapped.eth',
-    newOwnerAddress: accounts[1],
-    newRegistrantAddress: accounts[1],
-    account: accounts[1],
-  })
-  expect(tx).toBeTruthy()
-  const receipt = await waitForTransaction(tx)
-  expect(receipt.status).toBe('success')
-
-  const owner = await getOwner(publicClient, {
-    name: 'wrapped.eth',
-  })
-  expect(owner!.owner).toBe(accounts[1])
-  expect(owner!.registrant).toBe(accounts[1])
-  expect(owner!.ownershipLevel).toBe('registrar')
-})
-it('should return a regular unwrap name transaction and succeed', async () => {
-  const tx = await unwrapName(walletClient, {
-    name: 'test.wrapped-with-subnames.eth',
-    newOwnerAddress: accounts[1],
-    account: accounts[2],
-  })
-  expect(tx).toBeTruthy()
-  const receipt = await waitForTransaction(tx)
-  expect(receipt.status).toBe('success')
-
-  const owner = await getOwner(publicClient, {
-    name: 'test.wrapped-with-subnames.eth',
-  })
-  expect(owner!.owner).toBe(accounts[1])
-  expect(owner!.ownershipLevel).toBe('registry')
-})
-it('should error if newRegistrantAddress is not specified for .eth', async () => {
-  await expect(
-    unwrapName(walletClient, {
-      name: 'wrapped.eth',
-      newOwnerAddress: accounts[1],
-      account: accounts[1],
-    } as any),
-  ).rejects.toThrowErrorMatchingInlineSnapshot(`
-    "Required parameter not specified: newRegistrantAddress
-
-    Details: Must provide newRegistrantAddress for eth-2ld names
-
-    Version: ${getVersion()}"
-  `)
-})
-it('should error if newRegistrantAddress is specified for non .eth', async () => {
-  await expect(
-    unwrapName(walletClient, {
-      name: 'test.wrapped-with-subnames.eth',
-      newOwnerAddress: accounts[1],
-      newRegistrantAddress: accounts[1],
-      account: accounts[2],
-    } as any),
-  ).rejects.toThrowErrorMatchingInlineSnapshot(`
-    "Additional parameter specified: newRegistrantAddress
-
-    - Allowed parameters: name, newOwnerAddress
-
-    Details: newRegistrantAddress can only be specified for eth-2ld names
-
-    Version: ${getVersion()}"
-  `)
-})

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

@@ -1,195 +0,0 @@
-import type { Address, Hex } from 'viem'
-import { getChainContractAddress } from '../../contracts/getChainContractAddress.js'
-import { registrySetApprovalForAllSnippet } from '../../contracts/registry.js'
-import { getVersion } from '../../errors/error-utils.js'
-import {
-  publicClient,
-  testClient,
-  waitForTransaction,
-  walletClient,
-} from '../../tests/addTestContracts.js'
-import getOwner from '../public/getOwner.js'
-import getResolver from '../public/getResolver.js'
-import getWrapperData from '../public/getWrapperData.js'
-import wrapName from './wrapName.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 approve = async () => {
-  return walletClient.writeContract({
-    abi: registrySetApprovalForAllSnippet,
-    address: getChainContractAddress({
-      client: walletClient,
-      contract: 'ensRegistry',
-    }),
-    functionName: 'setApprovalForAll',
-    args: [
-      getChainContractAddress({
-        client: walletClient,
-        contract: 'ensNameWrapper',
-      }),
-      true,
-    ],
-    account: accounts[2],
-  })
-}
-
-describe('eth 2ld', () => {
-  it('should return a wrap name transaction and succeed', async () => {
-    const tx = await wrapName(walletClient, {
-      name: 'test123.eth',
-      newOwnerAddress: accounts[2],
-      account: accounts[1],
-    })
-    expect(tx).toBeTruthy()
-    const receipt = await waitForTransaction(tx)
-    expect(receipt.status).toBe('success')
-
-    const owner = await getOwner(publicClient, {
-      name: 'test123.eth',
-    })
-    expect(owner!.owner).toBe(accounts[2])
-    expect(owner!.ownershipLevel).toBe('nameWrapper')
-  })
-  it('should allow initial fuses', async () => {
-    const tx = await wrapName(walletClient, {
-      name: 'test123.eth',
-      newOwnerAddress: accounts[2],
-      fuses: {
-        named: ['CANNOT_UNWRAP', 'CANNOT_SET_TTL'],
-      },
-      account: accounts[1],
-    })
-    expect(tx).toBeTruthy()
-    const receipt = await waitForTransaction(tx)
-    expect(receipt.status).toBe('success')
-
-    const wrapperData = await getWrapperData(publicClient, {
-      name: 'test123.eth',
-    })
-    expect(wrapperData!.fuses.value).toBe(196625)
-  })
-  it('should allow a non-default resolver address', async () => {
-    const tx = await wrapName(walletClient, {
-      name: 'test123.eth',
-      newOwnerAddress: accounts[2],
-      resolverAddress: '0x42D63ae25990889E35F215bC95884039Ba354115',
-      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('0x42D63ae25990889E35F215bC95884039Ba354115')
-  })
-  it('should error for labels longer than 255 bytes', async () => {
-    const label = 'a'.repeat(256)
-    await expect(
-      wrapName(walletClient, {
-        name: `${label}.eth`,
-        newOwnerAddress: accounts[2],
-        account: accounts[1],
-      }),
-    ).rejects.toThrowErrorMatchingInlineSnapshot(`
-      "Supplied label was too long
-
-      - Supplied label: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
-      - Max byte length: 255
-      - Actual byte length: 256
-
-      Version: ${getVersion()}"
-    `)
-  })
-})
-
-describe('other', () => {
-  beforeEach(async () => {
-    await approve()
-  })
-  it('should return a wrap name transaction and succeed', async () => {
-    const tx = await wrapName(walletClient, {
-      name: 'test.with-subnames.eth',
-      newOwnerAddress: accounts[2],
-      account: accounts[2],
-    })
-    expect(tx).toBeTruthy()
-    const receipt = await waitForTransaction(tx)
-    expect(receipt.status).toBe('success')
-
-    const owner = await getOwner(publicClient, {
-      name: 'test.with-subnames.eth',
-    })
-    expect(owner!.owner).toBe(accounts[2])
-    expect(owner!.ownershipLevel).toBe('nameWrapper')
-  })
-  it('should allow a non-default resolver address', async () => {
-    const tx = await wrapName(walletClient, {
-      name: 'test.with-subnames.eth',
-      newOwnerAddress: accounts[2],
-      resolverAddress: '0x42D63ae25990889E35F215bC95884039Ba354115',
-      account: accounts[2],
-    })
-    expect(tx).toBeTruthy()
-    const receipt = await waitForTransaction(tx)
-    expect(receipt.status).toBe('success')
-
-    const resolver = await getResolver(publicClient, {
-      name: 'test.with-subnames.eth',
-    })
-    expect(resolver).toBe('0x42D63ae25990889E35F215bC95884039Ba354115')
-  })
-  it('should error if initial fuses are provided', async () => {
-    await expect(
-      wrapName(walletClient, {
-        name: 'test.with-subnames.eth',
-        newOwnerAddress: accounts[2],
-        fuses: {
-          named: ['CANNOT_UNWRAP', 'CANNOT_SET_TTL'],
-        } as any,
-        account: accounts[2],
-      }),
-    ).rejects.toThrowErrorMatchingInlineSnapshot(`
-      "Additional parameter specified: fuses
-
-      - Allowed parameters: name, wrappedOwner, resolverAddress
-
-      Details: Fuses cannot be initially set when wrapping non eth-2ld names
-
-      Version: ${getVersion()}"
-    `)
-  })
-  it('should error for a label longer than 255 bytes', async () => {
-    const label = 'a'.repeat(256)
-    await expect(
-      wrapName(walletClient, {
-        name: `${label}.with-subnames.eth`,
-        newOwnerAddress: accounts[2],
-        account: accounts[2],
-      }),
-    ).rejects.toThrowErrorMatchingInlineSnapshot(`
-      "Supplied label was too long
-
-      - Supplied label: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
-      - Max byte length: 255
-      - Actual byte length: 256
-
-      Version: ${getVersion()}"
-    `)
-  })
-})

package/src/utils/generateRecordCallArray.test.ts

@@ -1,84 +0,0 @@
-import { generateRecordCallArray } from './generateRecordCallArray.js'
-import { namehash } from './normalise.js'
-
-it('generates a record call array', () => {
-  expect(
-    generateRecordCallArray({
-      namehash: namehash('test.eth'),
-      clearRecords: true,
-      coins: [
-        { coin: 'ETH', value: '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266' },
-      ],
-
-      texts: [{ key: 'email', value: 'test@example.com' }],
-    }),
-  ).toMatchInlineSnapshot(`
-    [
-      "0x3603d758eb4f647bea6caa36333c816d7b46fdcb05f9466ecacc140ea8c66faf15b3d9f1",
-      "0x10f13a8ceb4f647bea6caa36333c816d7b46fdcb05f9466ecacc140ea8c66faf15b3d9f1000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000005656d61696c000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001074657374406578616d706c652e636f6d00000000000000000000000000000000",
-      "0x8b95dd71eb4f647bea6caa36333c816d7b46fdcb05f9466ecacc140ea8c66faf15b3d9f1000000000000000000000000000000000000000000000000000000000000003c00000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000014f39fd6e51aad88f6f4ce6ab8827279cfffb92266000000000000000000000000",
-    ]
-  `)
-})
-it('adds clearRecords call when clearRecords is true', () => {
-  expect(
-    generateRecordCallArray({
-      namehash: namehash('test.eth'),
-      clearRecords: true,
-    }),
-  ).toMatchInlineSnapshot(`
-    [
-      "0x3603d758eb4f647bea6caa36333c816d7b46fdcb05f9466ecacc140ea8c66faf15b3d9f1",
-    ]
-  `)
-})
-it('adds contentHash call when contentHash is defined', () => {
-  expect(
-    generateRecordCallArray({
-      namehash: namehash('test.eth'),
-      contentHash: 'ipfs://Qma8mnp6xV3J2cRNf3mTth5C8nV11CAnceVinc3y8jSbio',
-    }),
-  ).toMatchInlineSnapshot(`
-    [
-      "0x304e6adeeb4f647bea6caa36333c816d7b46fdcb05f9466ecacc140ea8c66faf15b3d9f100000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000026e30101701220af4147b366bee9eb9a21a9c2d5ccdde35fa4b8d2e0d44854fc81aeb894e8ce280000000000000000000000000000000000000000000000000000",
-    ]
-  `)
-})
-it('adds abi call when abi is defined', () => {
-  expect(
-    generateRecordCallArray({
-      namehash: namehash('test.eth'),
-      abi: { contentType: 0, encodedData: '0x' },
-    }),
-  ).toMatchInlineSnapshot(`
-    [
-      "0x623195b0eb4f647bea6caa36333c816d7b46fdcb05f9466ecacc140ea8c66faf15b3d9f1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000000",
-    ]
-  `)
-})
-it('adds text calls when texts array is defined and not empty', () => {
-  expect(
-    generateRecordCallArray({
-      namehash: namehash('test.eth'),
-      texts: [{ key: 'email', value: 'cool' }],
-    }),
-  ).toMatchInlineSnapshot(`
-    [
-      "0x10f13a8ceb4f647bea6caa36333c816d7b46fdcb05f9466ecacc140ea8c66faf15b3d9f1000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000005656d61696c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004636f6f6c00000000000000000000000000000000000000000000000000000000",
-    ]
-  `)
-})
-it('adds coin calls when coins array is defined and not empty', () => {
-  expect(
-    generateRecordCallArray({
-      namehash: namehash('test.eth'),
-      coins: [
-        { coin: 'ETH', value: '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266' },
-      ],
-    }),
-  ).toMatchInlineSnapshot(`
-    [
-      "0x8b95dd71eb4f647bea6caa36333c816d7b46fdcb05f9466ecacc140ea8c66faf15b3d9f1000000000000000000000000000000000000000000000000000000000000003c00000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000014f39fd6e51aad88f6f4ce6ab8827279cfffb92266000000000000000000000000",
-    ]
-  `)
-})