@ensdomains/ensjs 2.0.0 → 3.0.0-alpha.1

package/src/contracts/multicall.ts

@@ -0,0 +1,24 @@
+import { ethers } from 'ethers'
+import { Multicall__factory } from '../generated/factories/Multicall__factory'
+
+const ABI = [
+  'function aggregate(tuple(address target, bytes callData)[] calls) payable returns (uint256 blockNumber, bytes[] returnData)',
+  'function aggregate3(tuple(address target, bool allowFailure, bytes callData)[] calls) payable returns (tuple(bool success, bytes returnData)[] returnData)',
+  'function aggregate3Value(tuple(address target, bool allowFailure, uint256 value, bytes callData)[] calls) payable returns (tuple(bool success, bytes returnData)[] returnData)',
+  'function blockAndAggregate(tuple(address target, bytes callData)[] calls) payable returns (uint256 blockNumber, bytes32 blockHash, tuple(bool success, bytes returnData)[] returnData)',
+  'function getBasefee() view returns (uint256 basefee)',
+  'function getBlockHash(uint256 blockNumber) view returns (bytes32 blockHash)',
+  'function getBlockNumber() view returns (uint256 blockNumber)',
+  'function getChainId() view returns (uint256 chainid)',
+  'function getCurrentBlockCoinbase() view returns (address coinbase)',
+  'function getCurrentBlockDifficulty() view returns (uint256 difficulty)',
+  'function getCurrentBlockGasLimit() view returns (uint256 gaslimit)',
+  'function getCurrentBlockTimestamp() view returns (uint256 timestamp)',
+  'function getEthBalance(address addr) view returns (uint256 balance)',
+  'function getLastBlockHash() view returns (bytes32 blockHash)',
+  'function tryAggregate(bool requireSuccess, tuple(address target, bytes callData)[] calls) payable returns (tuple(bool success, bytes returnData)[] returnData)',
+  'function tryBlockAndAggregate(bool requireSuccess, tuple(address target, bytes callData)[] calls) payable returns (uint256 blockNumber, bytes32 blockHash, tuple(bool success, bytes returnData)[] returnData)',
+]
+
+export default (provider: ethers.providers.JsonRpcProvider, address: string) =>
+  Multicall__factory.connect(address, provider)

package/src/contracts/nameWrapper.ts

@@ -0,0 +1,5 @@
+import { ethers } from 'ethers'
+import { NameWrapper__factory } from '../generated/factories/NameWrapper__factory'
+
+export default (provider: ethers.providers.JsonRpcProvider, address: string) =>
+  NameWrapper__factory.connect(address, provider)

package/src/contracts/publicResolver.ts

@@ -0,0 +1,5 @@
+import { ethers } from 'ethers'
+import { PublicResolver__factory } from '../generated/factories/PublicResolver__factory'
+
+export default (provider: ethers.providers.JsonRpcProvider, address: string) =>
+  PublicResolver__factory.connect(address, provider)

package/src/contracts/registry.ts

@@ -0,0 +1,5 @@
+import { ethers } from 'ethers'
+import { ENSRegistry__factory } from '../generated/factories/ENSRegistry__factory'
+
+export default (provider: ethers.providers.JsonRpcProvider, address: string) =>
+  ENSRegistry__factory.connect(address, provider)

package/src/contracts/reverseRegistrar.ts

@@ -0,0 +1,5 @@
+import { ethers } from 'ethers'
+import { ReverseRegistrar__factory } from '../generated/factories/ReverseRegistrar__factory'
+
+export default (provider: ethers.providers.JsonRpcProvider, address: string) =>
+  ReverseRegistrar__factory.connect(address, provider)

package/src/contracts/types.ts

@@ -0,0 +1,11 @@
+export type SupportedNetworkId = '1' | '3' | '4' | '5' | '1337'
+
+export type ContractName =
+  | 'BaseRegistrarImplementation'
+  | 'ETHRegistrarController'
+  | 'Multicall'
+  | 'NameWrapper'
+  | 'PublicResolver'
+  | 'ENSRegistryWithFallback'
+  | 'ReverseRegistrar'
+  | 'UniversalResolver'

package/src/contracts/universalResolver.ts

@@ -0,0 +1,5 @@
+import { ethers } from 'ethers'
+import { UniversalResolver__factory } from '../generated/factories/UniversalResolver__factory'
+
+export default (provider: ethers.providers.JsonRpcProvider, address: string) =>
+  UniversalResolver__factory.connect(address, provider)

package/src/functions/batch.ts

@@ -0,0 +1,36 @@
+import { BatchFunctionResult, ENSArgs, RawFunction } from '..'
+
+const raw = async (
+  { multicallWrapper }: ENSArgs<'multicallWrapper'>,
+  ...items: BatchFunctionResult<RawFunction>[]
+) => {
+  const rawDataArr: { to: string; data: string }[] = await Promise.all(
+    items.map(({ args, raw }, i: number) => {
+      if (!raw) {
+        throw new Error(`Function ${i} is not batchable`)
+      }
+      return raw(...args)
+    }),
+  )
+  return multicallWrapper.raw(rawDataArr)
+}
+
+const decode = async (
+  { multicallWrapper }: ENSArgs<'multicallWrapper'>,
+  data: string,
+  ...items: BatchFunctionResult<RawFunction>[]
+): Promise<any[] | undefined> => {
+  const response = await multicallWrapper.decode(data)
+  if (!response) return
+
+  return Promise.all(
+    response.map((ret: any, i: number) =>
+      items[i].decode(ret.returnData, ...items[i].args),
+    ),
+  )
+}
+
+export default {
+  raw,
+  decode,
+}

package/src/functions/batchWrappers.ts

@@ -0,0 +1,91 @@
+import { ethers } from 'ethers'
+import { ENSArgs } from '..'
+import { hexEncodeName } from '../utils/hexEncodedName'
+
+export const universalWrapper = {
+  raw: async (
+    { contracts }: ENSArgs<'contracts'>,
+    name: string,
+    data: string,
+  ) => {
+    const universalResolver = await contracts?.getUniversalResolver()!
+    return {
+      to: universalResolver.address,
+      data: universalResolver.interface.encodeFunctionData('resolve', [
+        hexEncodeName(name),
+        data,
+      ]),
+    }
+  },
+  decode: async ({ contracts }: ENSArgs<'contracts'>, data: string) => {
+    const universalResolver = await contracts?.getUniversalResolver()!
+    const response = universalResolver.interface.decodeFunctionResult(
+      'resolve',
+      data,
+    )
+    if (!response || !response[0]) {
+      return
+    }
+    return { data: response[0], resolver: response[1] }
+  },
+}
+
+export const resolverMulticallWrapper = {
+  raw: async (
+    { contracts }: ENSArgs<'contracts'>,
+    data: { to: string; data: string }[],
+  ) => {
+    const publicResolver = await contracts?.getPublicResolver()!
+    const formattedDataArr = data.map((item) => (item as any).data)
+    return {
+      to: publicResolver.address,
+      data: publicResolver.interface.encodeFunctionData('multicall', [
+        formattedDataArr,
+      ]),
+    }
+  },
+  decode: async ({ contracts }: ENSArgs<'contracts'>, data: string) => {
+    const publicResolver = await contracts?.getPublicResolver()!
+    const response = publicResolver.interface.decodeFunctionResult(
+      'multicall',
+      data,
+    )
+    if (!response) {
+      return
+    }
+    return response
+  },
+}
+
+export const multicallWrapper = {
+  raw: async function (
+    { contracts }: ENSArgs<'contracts'>,
+    transactions: ethers.providers.TransactionRequest[],
+    requireSuccess: boolean = false,
+  ) {
+    const multicall = await contracts?.getMulticall()!
+    return {
+      to: multicall.address,
+      data: multicall.interface.encodeFunctionData('tryAggregate', [
+        requireSuccess,
+        transactions.map((tx) => ({
+          target: tx.to!,
+          callData: tx.data!,
+        })),
+      ]),
+    }
+  },
+  decode: async function ({ contracts }: ENSArgs<'contracts'>, data: string) {
+    if (!data) return
+    const multicall = await contracts?.getMulticall()!
+    try {
+      const [result] = multicall.interface.decodeFunctionResult(
+        'tryAggregate',
+        data,
+      )
+      return result
+    } catch {
+      return
+    }
+  },
+}

package/src/functions/burnFuses.ts

@@ -0,0 +1,23 @@
+import { ethers } from 'ethers'
+import { ENSArgs } from '..'
+import { FuseOptions } from '../@types/FuseOptions'
+import generateFuseInput from '../utils/generateFuseInput'
+
+export default async function (
+  { contracts, provider }: ENSArgs<'contracts' | 'provider'>,
+  name: string,
+  fusesToBurn: FuseOptions,
+) {
+  const signer = provider?.getSigner()
+
+  if (!signer) {
+    throw new Error('No signer found')
+  }
+
+  const nameWrapper = (await contracts?.getNameWrapper()!).connect(signer)
+  const namehash = ethers.utils.namehash(name)
+
+  const encodedFuses = generateFuseInput(fusesToBurn)
+
+  return nameWrapper.burnFuses(namehash, encodedFuses)
+}

package/src/functions/createSubname.ts

@@ -0,0 +1,82 @@
+import { ethers } from 'ethers'
+import { ENSArgs } from '..'
+import { FuseOptions } from '../@types/FuseOptions'
+import generateFuseInput from '../utils/generateFuseInput'
+
+type BaseArgs = {
+  name: string
+  owner: string
+  resolverAddress?: string
+  contract: 'registry' | 'nameWrapper'
+  options?: { addressOrIndex?: string | number }
+}
+
+type NameWrapperArgs = {
+  contract: 'nameWrapper'
+  fuses?: FuseOptions
+} & BaseArgs
+
+type Args = BaseArgs | NameWrapperArgs
+
+export default async function (
+  { contracts, provider }: ENSArgs<'contracts' | 'provider'>,
+  { name, owner, resolverAddress, contract, options, ...wrapperArgs }: Args,
+) {
+  const signer = provider?.getSigner(options?.addressOrIndex)
+
+  if (!signer) {
+    throw new Error('No signer found')
+  }
+
+  const labels = name.split('.')
+
+  if (labels.length === 1) {
+    throw new Error('Subnames in ENS.js can only be created for 2LDs, not TLDs')
+  }
+
+  if ('fuses' in wrapperArgs && contract === 'registry') {
+    throw new Error('Fuses can only be set on a wrapped name')
+  }
+
+  if (!resolverAddress) {
+    resolverAddress = (await contracts?.getPublicResolver())!.address
+  }
+
+  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.setSubnodeRecord(
+        parentNodehash,
+        labelhash,
+        owner,
+        resolverAddress,
+        0,
+      )
+    }
+    case 'nameWrapper': {
+      const nameWrapper = (await contracts?.getNameWrapper()!).connect(signer)
+
+      const generatedFuses =
+        'fuses' in wrapperArgs && wrapperArgs.fuses
+          ? generateFuseInput(wrapperArgs.fuses)
+          : '0'
+
+      return nameWrapper.setSubnodeRecord(
+        parentNodehash,
+        label,
+        owner,
+        resolverAddress,
+        0,
+        generatedFuses,
+      )
+    }
+    default: {
+      throw new Error(`Unknown contract: ${contract}`)
+    }
+  }
+}

package/src/functions/deleteSubname.ts

@@ -0,0 +1,19 @@
+import { ENSArgs } from '..'
+
+export default async function (
+  {
+    contracts,
+    provider,
+    transferSubname,
+  }: ENSArgs<'contracts' | 'provider' | 'transferSubname'>,
+  name: string,
+  contract: 'registry' | 'nameWrapper',
+  options?: { addressOrIndex?: string | number },
+) {
+  return transferSubname(
+    name,
+    contract,
+    '0x0000000000000000000000000000000000000000',
+    options,
+  )
+}

package/src/functions/getExpiry.ts

@@ -0,0 +1,63 @@
+import { BigNumber } from 'ethers'
+import { solidityKeccak256 } from 'ethers/lib/utils'
+import { ENSArgs } from '..'
+
+const raw = async (
+  { contracts, multicallWrapper }: ENSArgs<'contracts' | 'multicallWrapper'>,
+  name: string,
+) => {
+  const baseRegistrar = await contracts?.getBaseRegistrar()!
+
+  const labels = name.split('.')
+
+  if (labels.length > 2 || labels[1] !== 'eth') {
+    throw new Error('Only .eth names have expiry dates')
+  }
+
+  const expiryCall = baseRegistrar.interface.encodeFunctionData('nameExpires', [
+    solidityKeccak256(['string'], [labels[0]]),
+  ])
+  const gracePeriodCall =
+    baseRegistrar.interface.encodeFunctionData('GRACE_PERIOD')
+
+  return multicallWrapper.raw([
+    {
+      to: baseRegistrar.address,
+      data: expiryCall,
+    },
+    {
+      to: baseRegistrar.address,
+      data: gracePeriodCall,
+    },
+  ])
+}
+
+const decode = async (
+  { contracts, multicallWrapper }: ENSArgs<'contracts' | 'multicallWrapper'>,
+  data: string,
+) => {
+  if (data === null) return
+  const result = await multicallWrapper.decode(data)
+  const baseRegistrar = await contracts?.getBaseRegistrar()!
+  try {
+    const [nameExpires] = baseRegistrar.interface.decodeFunctionResult(
+      'nameExpires',
+      result[0].returnData,
+    )
+    const [gracePeriod] = baseRegistrar.interface.decodeFunctionResult(
+      'GRACE_PERIOD',
+      result[1].returnData,
+    )
+    return {
+      expiry: nameExpires > 0 ? new Date(nameExpires * 1000) : null,
+      gracePeriod: (gracePeriod as BigNumber).toNumber() * 1000,
+    }
+  } catch {
+    return
+  }
+}
+
+export default {
+  raw,
+  decode,
+}

package/src/functions/getFuses.ts

@@ -0,0 +1,75 @@
+import { BigNumber, ethers, utils } from 'ethers'
+import { ENSArgs } from '..'
+import { testable as fuseEnums } from '../utils/fuses'
+
+const NameSafety = [
+  'Safe',
+  'RegistrantNotWrapped',
+  'ControllerNotWrapped',
+  'SubdomainReplacementAllowed',
+  'Expired',
+]
+
+const raw = async ({ contracts }: ENSArgs<'contracts'>, name: string) => {
+  const nameWrapper = await contracts?.getNameWrapper()!
+  return {
+    to: nameWrapper.address,
+    data: nameWrapper.interface.encodeFunctionData('getFuses', [
+      ethers.utils.namehash(name),
+    ]),
+  }
+}
+
+const decode = async (
+  { contracts }: ENSArgs<'contracts'>,
+  data: string,
+  name: string,
+) => {
+  const nameWrapper = await contracts?.getNameWrapper()!
+  try {
+    const [fuses, vulnerability, vulnerableNode] =
+      nameWrapper.interface.decodeFunctionResult('getFuses', data)
+
+    const fuseObj = Object.fromEntries(
+      Object.keys(fuseEnums).map((fuseEnum) => [
+        fuseEnum
+          .toLowerCase()
+          .replace(/([-_][a-z])/g, (group: string) =>
+            group.toUpperCase().replace('-', '').replace('_', ''),
+          ),
+        fuses.and(fuseEnums[fuseEnum as keyof typeof fuseEnums]).gt(0),
+      ]),
+    )
+
+    if (fuses.eq(0)) {
+      fuseObj.canDoEverything = true
+    } else {
+      fuseObj.canDoEverything = false
+    }
+
+    let returnVulnerableNode: string | null = null
+    if (utils.hexStripZeros(vulnerableNode) !== '0x') {
+      name.split('.').forEach((label, index, arr) => {
+        const node = arr.slice(index).join('.')
+        const nodehash = utils.namehash(node)
+        if (nodehash === vulnerableNode) {
+          returnVulnerableNode = node
+        }
+      })
+    }
+
+    return {
+      fuseObj,
+      vulnerability: NameSafety[vulnerability] || vulnerability,
+      vulnerableNode: returnVulnerableNode,
+      rawFuses: fuses as BigNumber,
+    }
+  } catch {
+    return
+  }
+}
+
+export default {
+  raw,
+  decode,
+}