@ensdomains/ensjs 2.0.1 → 3.0.0-alpha.10

package/src/functions/getOwner.ts

@@ -0,0 +1,202 @@
+import { ethers } from 'ethers'
+import { ENSArgs } from '..'
+import { labelhash } from '../utils/labels'
+import { namehash as makeNamehash } from '../utils/normalise'
+
+type Owner = {
+  registrant?: string
+  owner?: string
+  ownershipLevel: 'nameWrapper' | 'registry' | 'registrar'
+}
+
+const singleContractOwnerRaw = async (
+  { contracts }: ENSArgs<'contracts'>,
+  contract: 'nameWrapper' | 'registry' | 'registrar',
+  namehash: string,
+  labels: string[],
+) => {
+  switch (contract) {
+    case 'nameWrapper': {
+      const nameWrapper = await contracts?.getNameWrapper()!
+
+      return {
+        to: nameWrapper.address,
+        data: nameWrapper.interface.encodeFunctionData('ownerOf', [namehash]),
+      }
+    }
+    case 'registry': {
+      const registry = await contracts?.getRegistry()!
+
+      return {
+        to: registry.address,
+        data: registry.interface.encodeFunctionData('owner', [namehash]),
+      }
+    }
+    case 'registrar': {
+      const registrar = await contracts?.getBaseRegistrar()!
+
+      return {
+        to: registrar.address,
+        data: registrar.interface.encodeFunctionData('ownerOf', [
+          labelhash(labels[0]),
+        ]),
+      }
+    }
+  }
+}
+
+const raw = async (
+  { contracts, multicallWrapper }: ENSArgs<'contracts' | 'multicallWrapper'>,
+  name: string,
+  contract?: 'nameWrapper' | 'registry' | 'registrar',
+) => {
+  const namehash = makeNamehash(name)
+  const labels = name.split('.')
+
+  if (contract || labels.length === 1) {
+    return await singleContractOwnerRaw(
+      { contracts },
+      contract || 'registry',
+      namehash,
+      labels,
+    )
+  }
+
+  const registryData = await singleContractOwnerRaw(
+    { contracts },
+    'registry',
+    namehash,
+    labels,
+  )
+  const nameWrapperData = await singleContractOwnerRaw(
+    { contracts },
+    'nameWrapper',
+    namehash,
+    labels,
+  )
+  const registrarData = await singleContractOwnerRaw(
+    { contracts },
+    'registrar',
+    namehash,
+    labels,
+  )
+
+  const data: { to: string; data: string }[] = [registryData, nameWrapperData]
+
+  if (labels.length == 2 && labels[1] === 'eth') {
+    data.push(registrarData)
+  }
+
+  return multicallWrapper.raw(data)
+}
+
+const singleContractOwnerDecode = (data: string) =>
+  ethers.utils.defaultAbiCoder.decode(['address'], data)[0]
+
+const decode = async (
+  { contracts, multicallWrapper }: ENSArgs<'contracts' | 'multicallWrapper'>,
+  data: string,
+  name: string,
+  contract?: 'nameWrapper' | 'registry' | 'registrar',
+): Promise<Owner | undefined> => {
+  if (data === null) return
+  const labels = name.split('.')
+  if (contract || labels.length === 1) {
+    const singleOwner = singleContractOwnerDecode(data)
+    let obj = {
+      ownershipLevel: contract || 'registry',
+    }
+    if (contract === 'registrar') {
+      return {
+        ...obj,
+        registrant: singleOwner as string,
+      }
+    } else {
+      return {
+        ...obj,
+        owner: singleOwner as string,
+      }
+    }
+  }
+  const result = await multicallWrapper.decode(data)
+  if (result === null) return
+  const nameWrapper = await contracts?.getNameWrapper()!
+
+  const decodedData = [result[0][1], result[1][1], result[2]?.[1]].map(
+    (ret) =>
+      ret &&
+      ret !== '0x' &&
+      ethers.utils.defaultAbiCoder.decode(['address'], ret),
+  )
+
+  const registryOwner = (decodedData[0] as ethers.utils.Result)[0]
+  const nameWrapperOwner = (decodedData[1] as ethers.utils.Result)[0]
+  const registrarOwner = (
+    decodedData[2] as ethers.utils.Result | undefined
+  )?.[0]
+
+  // check for only .eth names
+  if (labels[labels.length - 1] === 'eth') {
+    // if the owner on the registrar is the namewrapper, then the namewrapper owner is the owner
+    // there is no "registrant" for wrapped names
+    if (registrarOwner === nameWrapper.address) {
+      return {
+        owner: nameWrapperOwner,
+        ownershipLevel: 'nameWrapper',
+      }
+    }
+    // if there is a registrar owner, then it's not a subdomain but we have also passed the namewrapper clause
+    // this means that it's an unwrapped second-level name
+    // the registrant is the owner of the NFT
+    // the owner is the controller of the records
+    if (registrarOwner) {
+      return {
+        registrant: registrarOwner,
+        owner: registryOwner,
+        ownershipLevel: 'registrar',
+      }
+    }
+    if (
+      labels.length > 2 &&
+      ethers.utils.hexStripZeros(registryOwner) !== '0x'
+    ) {
+      // this means that the subname is wrapped
+      if (registryOwner === nameWrapper.address) {
+        return {
+          owner: nameWrapperOwner,
+          ownershipLevel: 'nameWrapper',
+        }
+      }
+      // unwrapped subnames do not have NFTs associated, so do not have a registrant
+      return {
+        owner: registryOwner,
+        ownershipLevel: 'registry',
+      }
+    }
+    // .eth names with no registrar owner are either unregistered or expired
+    return
+  }
+
+  // non .eth names inherit the owner from the registry
+  // there will only ever be an owner for non .eth names, not a registrant
+  // this is because for unwrapped names, there is no associated NFT
+  // and for wrapped names, owner and registrant are the same thing
+  if (registryOwner == nameWrapper.address) {
+    return {
+      owner: nameWrapperOwner,
+      ownershipLevel: 'nameWrapper',
+    }
+  }
+
+  // for unwrapped non .eth names, the owner is the registry owner
+  if (ethers.utils.hexStripZeros(registryOwner) !== '0x') {
+    return {
+      owner: registryOwner,
+      ownershipLevel: 'registry',
+    }
+  }
+
+  // for anything else, return
+  return
+}
+export default { raw, decode }

package/src/functions/getPrice.ts

@@ -0,0 +1,71 @@
+import { BigNumber, utils } from 'ethers'
+import { ENSArgs } from '..'
+
+const raw = async (
+  { contracts, multicallWrapper }: ENSArgs<'contracts' | 'multicallWrapper'>,
+  name: string,
+  duration: number,
+  legacy?: boolean,
+) => {
+  const controller = await contracts?.getEthRegistrarController()!
+
+  const baseCall = {
+    to: controller.address,
+    data: controller.interface.encodeFunctionData('rentPrice', [
+      name,
+      duration,
+    ]),
+  }
+
+  if (legacy) {
+    return multicallWrapper.raw([
+      baseCall,
+      {
+        to: controller.address,
+        data: controller.interface.encodeFunctionData('rentPrice', [name, 0]),
+      },
+    ])
+  }
+
+  return baseCall
+}
+
+const decode = async (
+  { contracts, multicallWrapper }: ENSArgs<'contracts' | 'multicallWrapper'>,
+  data: string,
+  _name: string,
+  _number: number,
+  legacy?: boolean,
+) => {
+  if (data === null) return
+  const controller = await contracts?.getEthRegistrarController()!
+  try {
+    let base: BigNumber
+    let premium: BigNumber
+    if (legacy) {
+      const result = await multicallWrapper.decode(data)
+      const [price] = utils.defaultAbiCoder.decode(
+        ['uint256'],
+        result[0].returnData,
+      ) as [BigNumber]
+      ;[premium] = utils.defaultAbiCoder.decode(
+        ['uint256'],
+        result[1].returnData,
+      ) as [BigNumber]
+      base = price.sub(premium)
+    } else {
+      ;[base, premium] = controller.interface.decodeFunctionData(
+        'rentPrice',
+        data,
+      ) as [BigNumber, BigNumber]
+    }
+    return {
+      base,
+      premium,
+    }
+  } catch {
+    return
+  }
+}
+
+export default { raw, decode }

package/src/functions/getProfile.test.ts

@@ -0,0 +1,135 @@
+import { ENS } from '..'
+import setup from '../tests/setup'
+
+let ENSInstance: ENS
+let revert: Awaited<ReturnType<typeof setup>>['revert']
+
+beforeAll(async () => {
+  ;({ ENSInstance, revert } = await setup())
+})
+
+afterAll(async () => {
+  await revert()
+})
+
+const checkRecords = (
+  result: Record<string, any> | undefined,
+  textLength = 3,
+  coinTypeLength = 5,
+) => {
+  expect(result).toBeDefined()
+  if (result) {
+    expect(result.records?.texts).toHaveLength(textLength)
+    expect(result.records?.coinTypes).toHaveLength(coinTypeLength)
+    expect(result.resolverAddress).toBe(
+      '0x42D63ae25990889E35F215bC95884039Ba354115',
+    )
+  }
+}
+
+jest.setTimeout(20000)
+
+describe('getProfile', () => {
+  describe('with an address', () => {
+    it('should return a profile object with no other args', async () => {
+      const result = await ENSInstance.getProfile(
+        '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+      )
+      expect(result).toBeDefined()
+      if (result) {
+        expect((result as any).name).toBe('jefflau.eth')
+        expect((result as any).address).toBeUndefined()
+        checkRecords(result)
+      }
+    })
+    it('should return a profile object with specified records', async () => {
+      const result = await ENSInstance.getProfile(
+        '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+        { texts: ['description', 'url'], coinTypes: ['ETC', '0'] },
+      )
+      expect(result).toBeDefined()
+      if (result) {
+        expect((result as any).name).toBe('jefflau.eth')
+        expect((result as any).address).toBeUndefined()
+        checkRecords(result, 2, 3)
+      }
+    })
+    it('should return a profile object with all of each specified record type', async () => {
+      const result = await ENSInstance.getProfile(
+        '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+        { texts: true, coinTypes: true },
+      )
+      checkRecords(result)
+    })
+    it('should return null for an address without a name', async () => {
+      const result = await ENSInstance.getProfile(
+        '0x8e8db5ccef88cca9d624701db544989c996e3216',
+      )
+      expect(result).toBeUndefined()
+    })
+  })
+  describe('with a name', () => {
+    it('should return a profile object with no other args', async () => {
+      const result = await ENSInstance.getProfile('jefflau.eth')
+      expect((result as any).address).toBe(
+        '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+      )
+      checkRecords(result)
+    })
+    it('should return a profile object with specified records', async () => {
+      const result = await ENSInstance.getProfile('jefflau.eth', {
+        texts: ['description', 'url'],
+        coinTypes: ['ETC', '0'],
+      })
+      expect((result as any).address).toBe(
+        '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+      )
+      checkRecords(result, 2, 3)
+    })
+    it('should return a profile object with all of each specified record type', async () => {
+      const result = await ENSInstance.getProfile('jefflau.eth', {
+        texts: true,
+        coinTypes: true,
+      })
+      checkRecords(result)
+    })
+    it('should return a profile object for a specified resolver', async () => {
+      const result = await ENSInstance.getProfile('saganaki.xyz', {
+        resolverAddress: '0x12299799a50340fb860d276805e78550cbad3de3',
+      })
+      expect(result).toBeDefined()
+      expect(result?.address).toBe('0x157545BfD441453921049998128Ff090c1c11230')
+      expect(result?.resolverAddress).toBe(
+        '0x12299799a50340fb860d276805e78550cbad3de3',
+      )
+    })
+    it('should return undefined for an unregistered name', async () => {
+      const result = await ENSInstance.getProfile('test123123123cool.eth')
+      expect(result).toBeUndefined()
+    })
+  })
+  describe('with an old resolver', () => {
+    it('should use fallback methods for a name with an older resolver (no multicall)', async () => {
+      const result = await ENSInstance.getProfile('pepeq6.eth')
+      expect(result).toBeDefined()
+      if (result) {
+        expect(result.address).toBe(
+          '0x6308F1c6f283583C8bf8E31Da793B87718b051eD',
+        )
+      }
+    })
+  })
+  describe('with an unmigrated name', () => {
+    beforeAll(async () => {
+      ;({ ENSInstance } = await setup(true))
+      jest.setTimeout(20000)
+    })
+    it('should return an object with isMigrated false and a message', async () => {
+      const result = await ENSInstance.getProfile('jefflau.test')
+      expect(result).toBeTruthy()
+      if (result) {
+        expect(result.isMigrated).toBe(false)
+      }
+    })
+  })
+})