@ensdomains/ensjs 3.0.0-alpha.8 → 3.0.0-beta.1

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

@@ -0,0 +1,69 @@
+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/setContentHashRecord.ts

@@ -0,0 +1,101 @@
+import type {
+  Account,
+  Address,
+  Hash,
+  SendTransactionParameters,
+  Transport,
+} from 'viem'
+import type { ChainWithEns, WalletWithEns } from '../../contracts/consts.js'
+import type {
+  Prettify,
+  SimpleTransactionRequest,
+  WriteTransactionParameters,
+} from '../../types.js'
+import { encodeSetContentHash } from '../../utils/encoders/encodeSetContentHash.js'
+import { namehash } from '../../utils/normalise.js'
+
+export type SetContentHashRecordDataParameters = {
+  /** Name to set content hash for */
+  name: string
+  /** Content hash value */
+  contentHash: string | null
+  /** Resolver address to set content hash on */
+  resolverAddress: Address
+}
+
+export type SetContentHashRecordDataReturnType = SimpleTransactionRequest
+
+export type SetContentHashRecordParameters<
+  TChain extends ChainWithEns,
+  TAccount extends Account | undefined,
+  TChainOverride extends ChainWithEns | undefined,
+> = Prettify<
+  SetContentHashRecordDataParameters &
+    WriteTransactionParameters<TChain, TAccount, TChainOverride>
+>
+
+export type SetContentHashRecordReturnType = Hash
+
+export const makeFunctionData = <
+  TChain extends ChainWithEns,
+  TAccount extends Account | undefined,
+>(
+  _wallet: WalletWithEns<Transport, TChain, TAccount>,
+  { name, contentHash, resolverAddress }: SetContentHashRecordDataParameters,
+): SetContentHashRecordDataReturnType => {
+  return {
+    to: resolverAddress,
+    data: encodeSetContentHash({ namehash: namehash(name), contentHash }),
+  }
+}
+
+/**
+ * Sets the content hash record for a name on a resolver.
+ * @param wallet - {@link WalletWithEns}
+ * @param parameters - {@link SetContentHashRecordParameters}
+ * @returns Transaction hash. {@link SetContentHashRecordReturnType}
+ *
+ * @example
+ * import { createWalletClient, custom } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { addEnsContracts, setContentHashRecord } from '@ensdomains/ensjs'
+ *
+ * const wallet = createWalletClient({
+ *   chain: addEnsContracts(mainnet),
+ *   transport: custom(window.ethereum),
+ * })
+ * const hash = await setContentHashRecord(wallet, {
+ *   name: 'ens.eth',
+ *   value: 'ipns://k51qzi5uqu5djdczd6zw0grmo23j2vkj9uzvujencg15s5rlkq0ss4ivll8wqw',
+ *   resolverAddress: '0x4976fb03C32e5B8cfe2b6cCB31c09Ba78EBaBa41',
+ * })
+ * // 0x...
+ */
+async function setContentHashRecord<
+  TChain extends ChainWithEns,
+  TAccount extends Account | undefined,
+  TChainOverride extends ChainWithEns | undefined = ChainWithEns,
+>(
+  wallet: WalletWithEns<Transport, TChain, TAccount>,
+  {
+    name,
+    contentHash,
+    resolverAddress,
+    ...txArgs
+  }: SetContentHashRecordParameters<TChain, TAccount, TChainOverride>,
+): Promise<SetContentHashRecordReturnType> {
+  const data = makeFunctionData(wallet, {
+    name,
+    contentHash,
+    resolverAddress,
+  })
+  const writeArgs = {
+    ...data,
+    ...txArgs,
+  } as SendTransactionParameters<TChain, TAccount, TChainOverride>
+  return wallet.sendTransaction(writeArgs)
+}
+
+setContentHashRecord.makeFunctionData = makeFunctionData
+
+export default setContentHashRecord

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

@@ -0,0 +1,287 @@
+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/setFuses.ts

@@ -0,0 +1,102 @@
+import {
+  encodeFunctionData,
+  type Account,
+  type Hash,
+  type SendTransactionParameters,
+  type Transport,
+} from 'viem'
+import type { ChainWithEns, WalletWithEns } from '../../contracts/consts.js'
+import { getChainContractAddress } from '../../contracts/getChainContractAddress.js'
+import { nameWrapperSetFusesSnippet } from '../../contracts/nameWrapper.js'
+import type {
+  Prettify,
+  SimpleTransactionRequest,
+  WriteTransactionParameters,
+} from '../../types.js'
+import { encodeFuses, type CombinedFuseInput } from '../../utils/fuses.js'
+import { namehash } from '../../utils/normalise.js'
+
+export type SetFusesDataParameters = {
+  /** Name to set fuses for */
+  name: string
+  /** Fuse object to set to */
+  fuses: Prettify<CombinedFuseInput['child']>
+}
+
+export type SetFusesDataReturnType = SimpleTransactionRequest
+
+export type SetFusesParameters<
+  TChain extends ChainWithEns,
+  TAccount extends Account | undefined,
+  TChainOverride extends ChainWithEns | undefined,
+> = Prettify<
+  SetFusesDataParameters &
+    WriteTransactionParameters<TChain, TAccount, TChainOverride>
+>
+
+export type SetFusesReturnType = Hash
+
+export const makeFunctionData = <
+  TChain extends ChainWithEns,
+  TAccount extends Account | undefined,
+>(
+  wallet: WalletWithEns<Transport, TChain, TAccount>,
+  { name, fuses }: SetFusesDataParameters,
+): SetFusesDataReturnType => {
+  const encodedFuses = encodeFuses(fuses, 'child')
+  return {
+    to: getChainContractAddress({ client: wallet, contract: 'ensNameWrapper' }),
+    data: encodeFunctionData({
+      abi: nameWrapperSetFusesSnippet,
+      functionName: 'setFuses',
+      args: [namehash(name), encodedFuses],
+    }),
+  }
+}
+
+/**
+ * Sets the fuses for a name.
+ * @param wallet - {@link WalletWithEns}
+ * @param parameters - {@link SetFusesParameters}
+ * @returns Transaction hash. {@link SetFusesReturnType}
+ *
+ * @example
+ * import { createWalletClient, custom } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { addEnsContracts, setFuses } from '@ensdomains/ensjs'
+ *
+ * const wallet = createWalletClient({
+ *   chain: addEnsContracts(mainnet),
+ *   transport: custom(window.ethereum),
+ * })
+ * const hash = await setFuses(wallet, {
+ *   name: 'sub.ens.eth',
+ *   fuses: {
+ *     named: ['CANNOT_TRANSFER'],
+ *   },
+ * })
+ * // 0x...
+ */
+async function setFuses<
+  TChain extends ChainWithEns,
+  TAccount extends Account | undefined,
+  TChainOverride extends ChainWithEns | undefined = ChainWithEns,
+>(
+  wallet: WalletWithEns<Transport, TChain, TAccount>,
+  {
+    name,
+    fuses,
+    ...txArgs
+  }: SetFusesParameters<TChain, TAccount, TChainOverride>,
+): Promise<SetFusesReturnType> {
+  const data = makeFunctionData(wallet, { name, fuses })
+  const writeArgs = {
+    ...data,
+    ...txArgs,
+  } as SendTransactionParameters<TChain, TAccount, TChainOverride>
+  return wallet.sendTransaction(writeArgs)
+}
+
+setFuses.makeFunctionData = makeFunctionData
+
+export default setFuses

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

@@ -0,0 +1,71 @@
+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')
+})