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

package/src/utils/ownerFromContract.ts

@@ -0,0 +1,70 @@
+import { encodeFunctionData, labelhash, type Hex } from 'viem'
+import { baseRegistrarOwnerOfSnippet } from '../contracts/baseRegistrar.js'
+import type { ClientWithEns } from '../contracts/consts.js'
+import { getChainContractAddress } from '../contracts/getChainContractAddress.js'
+import { nameWrapperOwnerOfSnippet } from '../contracts/nameWrapper.js'
+import { registryOwnerSnippet } from '../contracts/registry.js'
+import { InvalidContractTypeError } from '../errors/general.js'
+
+export type OwnerContract = 'nameWrapper' | 'registry' | 'registrar'
+
+export type OwnerFromContractArgs = {
+  client: ClientWithEns
+  contract: OwnerContract
+  namehash?: Hex
+  labels?: string[]
+} & (
+  | {
+      contract: Exclude<OwnerContract, 'registrar'>
+      namehash: Hex
+    }
+  | {
+      contract: 'registrar'
+      labels: string[]
+    }
+)
+
+export const ownerFromContract = ({
+  client,
+  contract,
+  namehash,
+  labels,
+}: OwnerFromContractArgs) => {
+  switch (contract) {
+    case 'nameWrapper':
+      return {
+        to: getChainContractAddress({ client, contract: 'ensNameWrapper' }),
+        data: encodeFunctionData({
+          abi: nameWrapperOwnerOfSnippet,
+          functionName: 'ownerOf',
+          args: [BigInt(namehash)],
+        }),
+      }
+    case 'registry':
+      return {
+        to: getChainContractAddress({ client, contract: 'ensRegistry' }),
+        data: encodeFunctionData({
+          abi: registryOwnerSnippet,
+          functionName: 'owner',
+          args: [namehash],
+        }),
+      }
+    case 'registrar':
+      return {
+        to: getChainContractAddress({
+          client,
+          contract: 'ensBaseRegistrarImplementation',
+        }),
+        data: encodeFunctionData({
+          abi: baseRegistrarOwnerOfSnippet,
+          functionName: 'ownerOf',
+          args: [BigInt(labelhash(labels[0]))],
+        }),
+      }
+    default:
+      throw new InvalidContractTypeError({
+        contractType: contract,
+        supportedContractTypes: ['nameWrapper', 'registry', 'registrar'],
+      })
+  }
+}

package/src/utils/registerHelpers.test.ts

@@ -0,0 +1,159 @@
+import { labelhash } from 'viem'
+import { getVersion } from '../errors/error-utils.js'
+import { namehash } from './normalise.js'
+import {
+  makeCommitment,
+  makeCommitmentFromTuple,
+  makeCommitmentTuple,
+  makeRegistrationTuple,
+  randomSecret,
+  type RegistrationParameters,
+} from './registerHelpers.js'
+
+describe('randomSecret()', () => {
+  it('generates a random secret with no args', () => {
+    const secret = randomSecret()
+    expect(secret).toHaveLength(66)
+  })
+  it('generates a random secret with a platform domain', () => {
+    const hash = namehash('test.eth')
+    const secret = randomSecret({ platformDomain: 'test.eth' })
+    expect(secret).toHaveLength(66)
+    expect(secret.slice(2, 10)).toEqual(hash.slice(2, 10))
+  })
+  it('generates a random secret with a campaign', () => {
+    const secret = randomSecret({ campaign: 1 })
+    expect(secret).toHaveLength(66)
+    expect(secret.slice(10, 18)).toEqual('00000001')
+  })
+  it('throws when campaign is too large', () => {
+    expect(() => randomSecret({ campaign: 0xffffffff + 1 }))
+      .toThrowErrorMatchingInlineSnapshot(`
+      "Campaign reference 4294967296 is too large
+
+      - Max campaign reference: 4294967295
+
+      Version: ${getVersion()}"
+    `)
+  })
+})
+
+describe('makeCommitmentTuple()', () => {
+  it('generates a commitment tuple', () => {
+    const tuple = makeCommitmentTuple({
+      name: 'test.eth',
+      owner: '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266',
+      duration: 31536000,
+      secret: '0xsecret',
+    })
+    // labelhash
+    expect(tuple[0]).toBe(labelhash('test'))
+    // owner
+    expect(tuple[1]).toBe('0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266')
+    // duration
+    expect(tuple[2]).toBe(31536000n)
+    // secret
+    expect(tuple[3]).toBe('0xsecret')
+    // resolver address
+    expect(tuple[4]).toBe('0x0000000000000000000000000000000000000000')
+    // records
+    expect(tuple[5]).toStrictEqual([])
+    // reverse record
+    expect(tuple[6]).toBe(false)
+    // owner controlled fuses
+    expect(tuple[7]).toBe(0)
+  })
+  it('encodes fuses when supplied', () => {
+    const tuple = makeCommitmentTuple({
+      name: 'test.eth',
+      owner: '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266',
+      duration: 31536000,
+      secret: '0xsecret',
+      fuses: {
+        named: ['CANNOT_UNWRAP', 'CANNOT_BURN_FUSES'],
+      },
+    })
+    expect(tuple[7]).toBe(3)
+  })
+  it('adds ETH coin when reverse record is supplied and no ETH coin is supplied', () => {
+    const tuple = makeCommitmentTuple({
+      name: 'test.eth',
+      owner: '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266',
+      duration: 31536000,
+      secret: '0xsecret',
+      reverseRecord: true,
+    })
+    expect(tuple[5]).toMatchInlineSnapshot(`
+      [
+        "0x8b95dd71eb4f647bea6caa36333c816d7b46fdcb05f9466ecacc140ea8c66faf15b3d9f1000000000000000000000000000000000000000000000000000000000000003c00000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000014f39fd6e51aad88f6f4ce6ab8827279cfffb92266000000000000000000000000",
+      ]
+    `)
+    expect(tuple[6]).toBe(true)
+  })
+  it('does not add ETH coin when reverse record is supplied and ETH coin is supplied', () => {
+    const tuple = makeCommitmentTuple({
+      name: 'test.eth',
+      owner: '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266',
+      duration: 31536000,
+      records: {
+        coins: [
+          { coin: 'ETH', value: '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266' },
+        ],
+      },
+      secret: '0xsecret',
+      reverseRecord: true,
+    })
+    expect(tuple[5]).toMatchInlineSnapshot(`
+      [
+        "0x8b95dd71eb4f647bea6caa36333c816d7b46fdcb05f9466ecacc140ea8c66faf15b3d9f1000000000000000000000000000000000000000000000000000000000000003c00000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000014f39fd6e51aad88f6f4ce6ab8827279cfffb92266000000000000000000000000",
+      ]
+    `)
+    expect(tuple[6]).toBe(true)
+  })
+})
+
+describe('makeRegistrationTuple()', () => {
+  it('replaces labelhash from commitment tuple with label', () => {
+    const data: RegistrationParameters = {
+      name: 'test.eth',
+      owner: '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266',
+      duration: 31536000,
+      secret: '0xsecret',
+    }
+    const commitmentTuple = makeCommitmentTuple(data)
+    const registrationTuple = makeRegistrationTuple(data)
+    expect(registrationTuple[0]).toBe('test')
+    expect(registrationTuple.slice(1)).toEqual(commitmentTuple.slice(1))
+  })
+})
+
+describe('makeCommitmentFromTuple()', () => {
+  it('generates a commitment from a tuple', () => {
+    const tuple = makeCommitmentTuple({
+      name: 'test.eth',
+      owner: '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266',
+      duration: 31536000,
+      secret:
+        '0xde99acb8241826c5b3012b2c7a05dc28043428744a9c39445b4707c92b3fc054',
+    })
+    const commitment = makeCommitmentFromTuple(tuple)
+    expect(commitment).toMatchInlineSnapshot(
+      `"0x0d7fe28313600187945700f6c6374cc0ba4a360df039b3e62d435506e69dbe63"`,
+    )
+  })
+})
+
+describe('makeCommitment()', () => {
+  it('generates a commitment from a RegistrationParameters', () => {
+    const commitment = makeCommitment({
+      name: 'test.eth',
+      owner: '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266',
+      duration: 31536000,
+      secret:
+        '0xde99acb8241826c5b3012b2c7a05dc28043428744a9c39445b4707c92b3fc054',
+    })
+    expect(commitment).toMatchInlineSnapshot(
+      `"0x0d7fe28313600187945700f6c6374cc0ba4a360df039b3e62d435506e69dbe63"`,
+    )
+  })
+})

package/src/utils/registerHelpers.ts

@@ -1,87 +1,155 @@
-import { utils } from 'ethers'
-import type { FuseOptions } from '../@types/FuseOptions'
-import type { PublicResolver } from '../generated'
-import generateFuseInput from './generateFuseInput'
-import { labelhash } from './labels'
-import { namehash } from './normalise'
-import { generateRecordCallArray, RecordOptions } from './recordHelpers'
+import {
+  encodeAbiParameters,
+  keccak256,
+  labelhash,
+  pad,
+  toBytes,
+  toHex,
+  type Address,
+  type Hex,
+} from 'viem'
+import { CampaignReferenceTooLargeError } from '../errors/utils.js'
+import { EMPTY_ADDRESS } from './consts.js'
+import { encodeFuses, hasFuses, type CombinedFuseInput } from './fuses.js'
+import {
+  generateRecordCallArray,
+  type RecordOptions,
+} from './generateRecordCallArray.js'
+import { namehash } from './normalise.js'
 
-export const randomSecret = () => {
-  const bytes = Buffer.allocUnsafe(32)
-  return '0x' + crypto.getRandomValues(bytes).toString('hex')
+export type RegistrationParameters = {
+  /** Name to register */
+  name: string
+  /** Address to set owner to */
+  owner: Address
+  /** Duration of registration */
+  duration: number
+  /** Random 32 bytes to use for registration */
+  secret: Hex
+  /** Custom resolver address, defaults to current public resolver deployment */
+  resolverAddress?: Address
+  /** Records to set upon registration */
+  records?: RecordOptions
+  /** Sets primary name upon registration */
+  reverseRecord?: boolean
+  /** Fuses to set upon registration */
+  fuses?: CombinedFuseInput['child']
 }
 
-export const makeCommitment = ({
+export type CommitmentTuple = [
+  labelHash: Hex,
+  owner: Address,
+  duration: bigint,
+  secret: Hex,
+  resolver: Address,
+  data: Hex[],
+  reverseRecord: boolean,
+  ownerControlledFuses: number,
+]
+
+export type RegistrationTuple = [
+  label: string,
+  owner: Address,
+  duration: bigint,
+  secret: Hex,
+  resolver: Address,
+  data: Hex[],
+  reverseRecord: boolean,
+  ownerControlledFuses: number,
+]
+
+export const randomSecret = ({
+  platformDomain,
+  campaign,
+}: {
+  platformDomain?: string
+  campaign?: number
+} = {}) => {
+  const bytes = crypto.getRandomValues(new Uint8Array(32))
+  if (platformDomain) {
+    const hash = toBytes(namehash(platformDomain))
+    for (let i = 0; i < 4; i += 1) {
+      bytes[i] = hash[i]
+    }
+  }
+  if (campaign) {
+    if (campaign > 0xffffffff)
+      throw new CampaignReferenceTooLargeError({ campaign })
+    const campaignBytes = pad(toBytes(campaign), { size: 4 })
+    for (let i = 0; i < 4; i += 1) {
+      bytes[i + 4] = campaignBytes[i]
+    }
+  }
+  return toHex(bytes)
+}
+
+export const makeCommitmentTuple = ({
   name,
   owner,
   duration,
-  resolver,
-  records,
+  resolverAddress = EMPTY_ADDRESS,
+  records: { coins = [], ...records } = { texts: [], coins: [] },
   reverseRecord,
   fuses,
-}: {
-  name: string
-  owner: string
-  duration: number
-  resolver: PublicResolver
-  records?: RecordOptions
-  reverseRecord?: boolean
-  fuses?: FuseOptions
-}) => {
-  const label = labelhash(name.split('.')[0])
+  secret,
+}: RegistrationParameters): CommitmentTuple => {
+  const labelHash = labelhash(name.split('.')[0])
   const hash = namehash(name)
-  const resolverAddress = resolver.address
-  const data = records ? generateRecordCallArray(hash, records, resolver) : []
-  const secret = randomSecret()
-  const fuseData = fuses ? generateFuseInput(fuses) : '0'
+  const fuseData = hasFuses(fuses) ? encodeFuses(fuses!, 'child') : 0
+
+  if (
+    reverseRecord &&
+    !coins.find(
+      (c) =>
+        c.coin === 'ETH' ||
+        (typeof c.coin === 'string' ? parseInt(c.coin) === 60 : c.coin === 60),
+    )
+  ) {
+    coins.push({ coin: 60, value: owner })
+  }
+
+  const data = records
+    ? generateRecordCallArray({ namehash: hash, coins, ...records })
+    : []
 
-  const commitment = _makeCommitment({
-    labelhash: label,
+  return [
+    labelHash,
     owner,
-    duration,
+    BigInt(duration),
     secret,
-    resolver: resolverAddress,
+    resolverAddress,
     data,
-    reverseRecord: !!reverseRecord,
-    fuses: fuseData,
-  })
+    !!reverseRecord,
+    fuseData,
+  ]
+}
 
-  return {
-    secret,
-    commitment,
-  }
+export const makeRegistrationTuple = (
+  params: RegistrationParameters,
+): RegistrationTuple => {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  const [_labelhash, ...commitmentData] = makeCommitmentTuple(params)
+  const label = params.name.split('.')[0]
+  return [label, ...commitmentData]
 }
 
-export const _makeCommitment = ({
-  labelhash,
-  owner,
-  duration,
-  secret,
-  resolver,
-  data,
-  reverseRecord,
-  fuses,
-}: {
-  labelhash: string
-  owner: string
-  duration: number
-  secret: string
-  resolver: string
-  data: string[]
-  reverseRecord: boolean
-  fuses: string
-}) => {
-  return utils.solidityKeccak256(
-    [
-      'bytes32',
-      'address',
-      'uint256',
-      'bytes32',
-      'address',
-      'bytes[]',
-      'bool',
-      'uint96',
-    ],
-    [labelhash, owner, duration, secret, resolver, data, reverseRecord, fuses],
+export const makeCommitmentFromTuple = (params: CommitmentTuple): Hex => {
+  return keccak256(
+    encodeAbiParameters(
+      [
+        { name: 'name', type: 'bytes32' },
+        { name: 'owner', type: 'address' },
+        { name: 'duration', type: 'uint256' },
+        { name: 'secret', type: 'bytes32' },
+        { name: 'resolver', type: 'address' },
+        { name: 'data', type: 'bytes[]' },
+        { name: 'reverseRecord', type: 'bool' },
+        { name: 'ownerControlledFuses', type: 'uint16' },
+      ],
+      params,
+    ),
   )
 }
+
+export const makeCommitment = (params: RegistrationParameters): Hex =>
+  makeCommitmentFromTuple(makeCommitmentTuple(params))

package/src/utils/validation.test.ts

@@ -0,0 +1,170 @@
+/* eslint-disable @typescript-eslint/naming-convention */
+import { getVersion } from '../errors/error-utils.js'
+import { parseInput, validateName } from './validation.js'
+
+declare namespace localStorage {
+  const getItem: jest.MockedFn<Storage['getItem']>
+  const setItem: jest.MockedFn<Storage['setItem']>
+  const removeItem: jest.MockedFn<Storage['removeItem']>
+}
+
+const labelsMock = {
+  '0x68371d7e884c168ae2022c82bd837d51837718a7f7dfb7aa3f753074a35e1d87':
+    'something',
+  '0x4f5b812789fc606be1b3b16908db13fc7a9adf7ca72641f84d75b47069d3d7f0': 'eth',
+}
+
+const labelsMockJSON = JSON.stringify(labelsMock)
+
+describe('validateName()', () => {
+  beforeEach(() => {
+    localStorage.getItem.mockClear()
+    localStorage.setItem.mockClear()
+    localStorage.getItem.mockImplementation(() => labelsMockJSON)
+  })
+  it('should throw if the name has an empty label', () => {
+    expect(() => validateName('foo..bar')).toThrowError(
+      'Name cannot have empty labels',
+    )
+    expect(() => validateName('.foo.bar')).toThrowError(
+      'Name cannot have empty labels',
+    )
+    expect(() => validateName('foo.bar.')).toThrowError(
+      'Name cannot have empty labels',
+    )
+  })
+  it('should allow names with [root] as a label', () => {
+    expect(validateName('[root]')).toEqual('[root]')
+  })
+  it('should throw if the name has [root] as a label and is not the only label', () => {
+    expect(() => validateName('foo.[root].bar'))
+      .toThrowErrorMatchingInlineSnapshot(`
+      "Root name cannot have other labels
+
+      - Supplied name: foo.[root].bar
+
+      Version: ${getVersion()}"
+    `)
+  })
+
+  it('should get the decoded label hash from local storage', () => {
+    expect(
+      validateName(
+        'thing.[68371d7e884c168ae2022c82bd837d51837718a7f7dfb7aa3f753074a35e1d87].eth',
+      ),
+    ).toEqual('thing.something.eth')
+    expect(localStorage.getItem).toHaveBeenCalled()
+  })
+  it('should fallback to encoded label hash if the decoded label hash is not in local storage', () => {
+    expect(
+      validateName(
+        'something.[8c6c947d200f53fa1127b152f95b118f9e1d0eeb06fc678b6fc8a6d5c6fc5e17].eth',
+      ),
+    ).toEqual(
+      'something.[8c6c947d200f53fa1127b152f95b118f9e1d0eeb06fc678b6fc8a6d5c6fc5e17].eth',
+    )
+    expect(localStorage.getItem).toHaveBeenCalled()
+    expect(
+      validateName(
+        '[8c6c947d200f53fa1127b152f95b118f9e1d0eeb06fc678b6fc8a6d5c6fc5e17]',
+      ),
+    ).toEqual(
+      '[8c6c947d200f53fa1127b152f95b118f9e1d0eeb06fc678b6fc8a6d5c6fc5e17]',
+    )
+  })
+  it('should normalise the name', () => {
+    expect(validateName('aAaaA.eth')).toEqual('aaaaa.eth')
+  })
+  it('should save the normalised name to local storage', () => {
+    validateName('swAgCity.eth')
+    expect(localStorage.setItem).toHaveBeenCalledWith(
+      'ensjs:labels',
+      JSON.stringify({
+        ...labelsMock,
+        '0xee3bbc5c1db3f1dbd5ec4cdfd627fb76aba6215d814354b6c0f8d74253adf1a8':
+          'swagcity',
+      }),
+    )
+  })
+  it('should return the normalised name', () => {
+    expect(validateName('swAgCity.eth')).toEqual('swagcity.eth')
+  })
+})
+
+describe('parseInput()', () => {
+  it('should parse the input', () => {
+    expect(parseInput('bar.eth')).toEqual({
+      type: 'name',
+      normalised: 'bar.eth',
+      isShort: false,
+      isValid: true,
+      is2LD: true,
+      isETH: true,
+      labelDataArray: expect.any(Array),
+    })
+  })
+  it('should return a normalised name', () => {
+    expect(parseInput('bAr.etH').normalised).toEqual('bar.eth')
+  })
+  it('should parse the input if it is invalid', () => {
+    expect(parseInput('bar..eth')).toEqual({
+      type: 'name',
+      normalised: undefined,
+      isShort: false,
+      isValid: false,
+      is2LD: false,
+      isETH: true,
+      labelDataArray: expect.any(Array),
+    })
+  })
+  it('should return type as label if input is a label', () => {
+    expect(parseInput('bar').type).toEqual('label')
+  })
+  describe('should return correct value', () => {
+    describe('isShort', () => {
+      it('should return true if input is label and less than 3 characters', () => {
+        expect(parseInput('ba').isShort).toEqual(true)
+      })
+      it('should return true if input is less than 3 char emoji', () => {
+        expect(parseInput('🇺🇸').isShort).toEqual(true)
+      })
+      it('should return false if input is 3 char emoji', () => {
+        expect(parseInput('🏳️‍🌈').isShort).toEqual(false)
+      })
+      it('should return false if input is label and 3 characters', () => {
+        expect(parseInput('bar').isShort).toEqual(false)
+      })
+      it('should return true if input is 2LD .eth name and label is less than 3 characters', () => {
+        expect(parseInput('ba.eth').isShort).toEqual(true)
+      })
+      it('should return false if input is 2LD .eth name and label is 3 characters', () => {
+        expect(parseInput('bar.eth').isShort).toEqual(false)
+      })
+      it('should return false if input is 2LD other name and label is less than 3 characters', () => {
+        expect(parseInput('ba.com').isShort).toEqual(false)
+      })
+      it('should return false if input is 3LD .eth name and label is less than 3 characters', () => {
+        expect(parseInput('ba.bar.eth').isShort).toEqual(false)
+      })
+    })
+    describe('is2LD', () => {
+      it('should return true if input is 2LD name', () => {
+        expect(parseInput('bar.eth').is2LD).toEqual(true)
+      })
+      it('should return false if input is 3LD name', () => {
+        expect(parseInput('bar.foo.eth').is2LD).toEqual(false)
+      })
+      it('should return false if input is label', () => {
+        expect(parseInput('bar').is2LD).toEqual(false)
+      })
+    })
+    describe('isETH', () => {
+      it('should return true if input is .eth name', () => {
+        expect(parseInput('bar.eth').isETH).toEqual(true)
+      })
+      it('should return false if input is other name', () => {
+        expect(parseInput('bar.com').isETH).toEqual(false)
+      })
+    })
+  })
+})