@ensdomains/ensjs 2.0.0 → 3.0.0-alpha.1

package/src/functions/transferName.ts

@@ -0,0 +1,56 @@
+import { ethers } from 'ethers'
+import { ENSArgs } from '..'
+
+export default async function (
+  { contracts, provider }: ENSArgs<'contracts' | 'provider'>,
+  name: string,
+  newOwner: string,
+  contract: 'registry' | 'nameWrapper' | 'baseRegistrar',
+  options?: { addressOrIndex?: string | number },
+) {
+  const address = await provider
+    ?.getSigner(options?.addressOrIndex)
+    .getAddress()
+
+  if (!address) {
+    throw new Error('No signer found')
+  }
+
+  switch (contract) {
+    case 'registry': {
+      const registry = (await contracts?.getRegistry())!.connect(
+        provider?.getSigner(options?.addressOrIndex)!,
+      )
+      return registry.setOwner(ethers.utils.namehash(name), newOwner)
+    }
+    case 'baseRegistrar': {
+      const baseRegistrar = (await contracts?.getBaseRegistrar())!.connect(
+        provider?.getSigner(options?.addressOrIndex)!,
+      )
+      const labels = name.split('.')
+      if (labels.length > 2 || labels[labels.length - 1] !== 'eth') {
+        throw new Error('Invalid name for baseRegistrar')
+      }
+      return baseRegistrar['safeTransferFrom(address,address,uint256)'](
+        address,
+        newOwner,
+        ethers.utils.solidityKeccak256(['string'], [labels[0]]),
+      )
+    }
+    case 'nameWrapper': {
+      const nameWrapper = (await contracts?.getNameWrapper())!.connect(
+        provider?.getSigner(options?.addressOrIndex)!,
+      )
+      return nameWrapper.safeTransferFrom(
+        address,
+        newOwner,
+        ethers.utils.namehash(name),
+        1,
+        '0x',
+      )
+    }
+    default: {
+      throw new Error(`Unknown contract: ${contract}`)
+    }
+  }
+}

package/src/functions/transferSubname.ts

@@ -0,0 +1,37 @@
+import { ethers } from 'ethers'
+import { ENSArgs } from '..'
+
+export default async function (
+  { contracts, provider }: ENSArgs<'contracts' | 'provider'>,
+  name: string,
+  contract: 'registry' | 'nameWrapper',
+  address: string,
+  options?: { addressOrIndex?: string | number },
+) {
+  const signer = provider?.getSigner(options?.addressOrIndex)
+
+  if (!signer) {
+    throw new Error('No signer found')
+  }
+
+  const labels = name.split('.')
+  const label = labels.shift() as string
+  const labelhash = ethers.utils.solidityKeccak256(['string'], [label])
+  const parentNodehash = ethers.utils.namehash(labels.join('.'))
+
+  switch (contract) {
+    case 'registry': {
+      const registry = (await contracts?.getRegistry()!).connect(signer)
+
+      return registry.setSubnodeOwner(parentNodehash, labelhash, address)
+    }
+    case 'nameWrapper': {
+      const nameWrapper = (await contracts?.getNameWrapper()!).connect(signer)
+
+      return nameWrapper.setSubnodeOwner(parentNodehash, label, address, '0')
+    }
+    default: {
+      throw new Error(`Unknown contract: ${contract}`)
+    }
+  }
+}

package/src/functions/unwrapName.ts

@@ -0,0 +1,38 @@
+import { utils } from 'ethers'
+import { ENSArgs } from '..'
+
+export default async function (
+  { contracts, provider }: ENSArgs<'contracts' | 'provider'>,
+  name: string,
+  newController: string,
+  newRegistrant?: string,
+  options?: { addressOrIndex?: string | number },
+) {
+  const signer = provider?.getSigner(options?.addressOrIndex)
+
+  const address = await signer?.getAddress()
+
+  if (!signer || !address) {
+    throw new Error('No signer found')
+  }
+
+  const labels = name.split('.')
+  const labelhash = utils.solidityKeccak256(['string'], [labels[0]])
+  const parentNodehash = utils.namehash(labels.slice(1).join('.'))
+
+  const nameWrapper = (await contracts?.getNameWrapper()!).connect(signer)
+
+  if (labels.length === 2 && labels[1] === 'eth') {
+    if (!newRegistrant) {
+      throw new Error('newRegistrant must be specified for .eth names')
+    }
+
+    return nameWrapper.unwrapETH2LD(labelhash, newRegistrant, newController)
+  } else {
+    if (newRegistrant) {
+      throw new Error('newRegistrant can only be specified for .eth names')
+    }
+
+    return nameWrapper.unwrap(parentNodehash, labelhash, newController)
+  }
+}

package/src/functions/wrapName.ts

@@ -0,0 +1,128 @@
+import { ethers } from 'ethers'
+import { ENSArgs } from '..'
+import type { FuseOptions } from '../@types/FuseOptions'
+import generateFuseInput from '../utils/generateFuseInput'
+import { hexEncodeName } from '../utils/hexEncodedName'
+
+async function wrapETH(
+  { contracts }: ENSArgs<'contracts'>,
+  labels: string[],
+  wrappedOwner: string,
+  decodedFuses: string,
+  resolverAddress: string,
+  signer: ethers.Signer,
+  address: string,
+) {
+  const nameWrapper = await contracts?.getNameWrapper()!
+  const baseRegistrar = (await contracts?.getBaseRegistrar()!).connect(signer)
+
+  const labelhash = ethers.utils.solidityKeccak256(['string'], [labels[0]])
+
+  const data = ethers.utils.defaultAbiCoder.encode(
+    ['string', 'address', 'uint96', 'address'],
+    [labels[0], wrappedOwner, decodedFuses, resolverAddress],
+  )
+
+  return baseRegistrar['safeTransferFrom(address,address,uint256,bytes)'](
+    address,
+    nameWrapper.address,
+    labelhash,
+    data,
+  )
+}
+
+async function wrapOther(
+  { contracts }: ENSArgs<'contracts'>,
+  name: string,
+  wrappedOwner: string,
+  decodedFuses: string,
+  resolverAddress: string,
+  address: string,
+) {
+  const nameWrapper = await contracts?.getNameWrapper()!
+  const registry = await contracts?.getRegistry()!
+
+  const hasApproval = await registry.isApprovedForAll(
+    address,
+    nameWrapper.address,
+  )
+
+  if (!hasApproval) {
+    throw new Error(
+      'NameWrapper must have approval to wrap a name from this address.',
+    )
+  }
+
+  return nameWrapper.wrap(
+    hexEncodeName(name),
+    wrappedOwner,
+    decodedFuses,
+    resolverAddress,
+  )
+}
+
+export default async function (
+  { contracts, provider }: ENSArgs<'contracts' | 'provider'>,
+  name: string,
+  wrappedOwner: string,
+  fuseOptions?: FuseOptions | string | number,
+  resolverAddress?: string,
+  options?: { addressOrIndex?: string | number },
+) {
+  const signer = provider?.getSigner(options?.addressOrIndex)
+
+  const address = await signer?.getAddress()
+
+  if (!signer || !address) {
+    throw new Error('No signer found')
+  }
+
+  let decodedFuses: string
+
+  switch (typeof fuseOptions) {
+    case 'object': {
+      decodedFuses = generateFuseInput(fuseOptions)
+      break
+    }
+    case 'number': {
+      decodedFuses = fuseOptions.toString(16)
+      break
+    }
+    case 'string': {
+      decodedFuses = fuseOptions
+      break
+    }
+    case 'undefined': {
+      decodedFuses = '0'
+      break
+    }
+    default: {
+      throw new Error(`Invalid fuseOptions type: ${typeof fuseOptions}`)
+    }
+  }
+
+  const publicResolver = await contracts?.getPublicResolver()!
+  if (!resolverAddress) resolverAddress = publicResolver.address
+
+  const labels = name.split('.')
+  if (labels.length < 3 && labels[labels.length - 1] === 'eth') {
+    return wrapETH(
+      { contracts },
+      labels,
+      wrappedOwner,
+      decodedFuses,
+      resolverAddress,
+      signer,
+      address,
+    )
+  } else {
+    return wrapOther(
+      { contracts },
+      name,
+      wrappedOwner,
+      decodedFuses,
+      resolverAddress,
+      address,
+    )
+  }
+}