@ensdomains/ensjs 2.1.0 → 3.0.0-alpha.3

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.test.ts

@@ -0,0 +1,36 @@
+import { ENS } from '..'
+import setup from '../tests/setup'
+
+let ENSInstance: ENS
+
+beforeAll(async () => {
+  ;({ ENSInstance } = await setup())
+})
+
+describe('batch', () => {
+  it('should batch calls together', async () => {
+    const result = await ENSInstance.batch(
+      ENSInstance.getText.batch('jefflau.eth', 'description'),
+      ENSInstance.getAddr.batch('jefflau.eth'),
+      ENSInstance.getName.batch('0x866B3c4994e1416B7C738B9818b31dC246b95eEE'),
+    )
+    expect(result).toBeTruthy()
+    if (result) {
+      expect(result[0]).toBe('Hello2')
+      expect(result[1]).toBe('0x866B3c4994e1416B7C738B9818b31dC246b95eEE')
+      expect(result[2]).toMatchObject({
+        name: 'jefflau.eth',
+        match: true,
+      })
+    }
+  })
+  it('should batch a single call', async () => {
+    const result = await ENSInstance.batch(
+      ENSInstance.getText.batch('jefflau.eth', 'description'),
+    )
+    expect(result).toBeTruthy()
+    if (result) {
+      expect(result[0]).toBe('Hello2')
+    }
+  })
+})

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.test.ts

@@ -0,0 +1,31 @@
+import { ENS } from '..'
+import setup from '../tests/setup'
+
+let ENSInstance: ENS
+
+beforeAll(async () => {
+  ;({ ENSInstance } = await setup())
+})
+
+describe('batchWrappers', () => {
+  it('should batch calls together', async () => {
+    const batch = await ENSInstance.resolverMulticallWrapper.raw([
+      await ENSInstance._getText.raw('jefflau.eth', 'description'),
+      await ENSInstance._getText.raw('jefflau.eth', 'url'),
+      await ENSInstance._getAddr.raw('jefflau.eth'),
+    ])
+    const universalResponse = await ENSInstance.universalWrapper(
+      'jefflau.eth',
+      batch.data,
+    )
+    const [batchDecoded] = await ENSInstance.resolverMulticallWrapper.decode(
+      universalResponse?.data,
+    )
+    const decoded1 = await ENSInstance._getText.decode(batchDecoded[0])
+    const decoded2 = await ENSInstance._getText.decode(batchDecoded[1])
+    const decoded3 = await ENSInstance._getAddr.decode(batchDecoded[2])
+    expect(decoded1).toBe('Hello2')
+    expect(decoded2).toBe('twitter.com')
+    expect(decoded3).toBe('0x866B3c4994e1416B7C738B9818b31dC246b95eEE')
+  })
+})

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.test.ts

@@ -0,0 +1,44 @@
+import { BigNumber, ethers } from 'ethers'
+import { ENS } from '..'
+import { namehash } from '../utils/normalise'
+import setup from '../tests/setup'
+
+let ENSInstance: ENS
+let revert: Awaited<ReturnType<typeof setup>>['revert']
+let provider: ethers.providers.JsonRpcProvider
+let accounts: string[]
+
+beforeAll(async () => {
+  ;({ ENSInstance, revert, provider } = await setup())
+  accounts = await provider.listAccounts()
+})
+
+afterAll(async () => {
+  await revert()
+})
+
+describe('burnFuses', () => {
+  beforeEach(async () => {
+    await revert()
+  })
+  it('should return a burnFuses transaction and succeed', async () => {
+    const wrapNameTx = await ENSInstance.wrapName(
+      'parthtejpal.eth',
+      accounts[0],
+    )
+    await wrapNameTx.wait()
+
+    const tx = await ENSInstance.burnFuses('parthtejpal.eth', {
+      cannotUnwrap: true,
+      cannotCreateSubdomain: true,
+      cannotSetTtl: true,
+    })
+    expect(tx).toBeTruthy()
+    await tx.wait()
+
+    const nameWrapper = await ENSInstance.contracts!.getNameWrapper()!
+    const result = await nameWrapper.getFuses(namehash('parthtejpal.eth'))
+    const fuseBN = result.fuses as BigNumber
+    expect(fuseBN.toHexString()).toBe('0x71')
+  })
+})

package/src/functions/burnFuses.ts

@@ -0,0 +1,23 @@
+import { ENSArgs } from '..'
+import { FuseOptions } from '../@types/FuseOptions'
+import generateFuseInput from '../utils/generateFuseInput'
+import { namehash } from '../utils/normalise'
+
+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 hash = namehash(name)
+
+  const encodedFuses = generateFuseInput(fusesToBurn)
+
+  return nameWrapper.burnFuses(hash, encodedFuses)
+}

package/src/functions/createSubname.test.ts

@@ -0,0 +1,58 @@
+import { ethers } from 'ethers'
+import { ENS } from '..'
+import { namehash } from '../utils/normalise'
+import setup from '../tests/setup'
+
+let ENSInstance: ENS
+let revert: Awaited<ReturnType<typeof setup>>['revert']
+let createSnapshot: Awaited<ReturnType<typeof setup>>['createSnapshot']
+let provider: ethers.providers.JsonRpcProvider
+let accounts: string[]
+
+beforeAll(async () => {
+  ;({ ENSInstance, revert, createSnapshot, provider } = await setup())
+  accounts = await provider.listAccounts()
+})
+
+afterAll(async () => {
+  await revert()
+})
+
+describe('createSubname', () => {
+  beforeEach(async () => {
+    await revert()
+  })
+  it('should allow creating a subname on the registry', async () => {
+    const tx = await ENSInstance.createSubname({
+      contract: 'registry',
+      name: 'test.parthtejpal.eth',
+      owner: accounts[0],
+      options: { addressOrIndex: 0 },
+    })
+    expect(tx).toBeTruthy()
+    await tx.wait()
+
+    const registry = await ENSInstance.contracts!.getRegistry()!
+    const result = await registry.owner(namehash('test.parthtejpal.eth'))
+    expect(result).toBe(accounts[0])
+  })
+  it('should allow creating a subname on the namewrapper', async () => {
+    const wrapNameTx = await ENSInstance.wrapName(
+      'parthtejpal.eth',
+      accounts[0],
+    )
+    await wrapNameTx.wait()
+    const tx = await ENSInstance.createSubname({
+      contract: 'nameWrapper',
+      name: 'test.parthtejpal.eth',
+      owner: accounts[0],
+      options: { addressOrIndex: 0 },
+    })
+    expect(tx).toBeTruthy()
+    await tx.wait()
+
+    const nameWrapper = await ENSInstance.contracts!.getNameWrapper()!
+    const result = await nameWrapper.ownerOf(namehash('test.parthtejpal.eth'))
+    expect(result).toBe(accounts[0])
+  })
+})

package/src/functions/createSubname.ts

@@ -0,0 +1,83 @@
+import { ethers } from 'ethers'
+import { ENSArgs } from '..'
+import { FuseOptions } from '../@types/FuseOptions'
+import generateFuseInput from '../utils/generateFuseInput'
+import { namehash } from '../utils/normalise'
+
+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 = 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.test.ts

@@ -0,0 +1,71 @@
+import { ethers } from 'ethers'
+import { ENS } from '..'
+import { namehash } from '../utils/normalise'
+import setup from '../tests/setup'
+
+let ENSInstance: ENS
+let revert: Awaited<ReturnType<typeof setup>>['revert']
+let provider: ethers.providers.JsonRpcProvider
+let accounts: string[]
+
+beforeAll(async () => {
+  ;({ ENSInstance, revert, provider } = await setup())
+  accounts = await provider.listAccounts()
+})
+
+afterAll(async () => {
+  await revert()
+})
+
+describe('deleteSubname', () => {
+  beforeEach(async () => {
+    await revert()
+  })
+  it('should allow deleting a subname on the registry', async () => {
+    const createSubnameTx = await ENSInstance.createSubname({
+      contract: 'registry',
+      name: 'test.parthtejpal.eth',
+      owner: accounts[0],
+      options: { addressOrIndex: 0 },
+    })
+    await createSubnameTx.wait()
+
+    const tx = await ENSInstance.deleteSubname(
+      'test.parthtejpal.eth',
+      'registry',
+      { addressOrIndex: 0 },
+    )
+    expect(tx).toBeTruthy()
+    await tx.wait()
+
+    const registry = await ENSInstance.contracts!.getRegistry()!
+    const result = await registry.owner(namehash('test.parthtejpal.eth'))
+    expect(result).toBe('0x0000000000000000000000000000000000000000')
+  })
+  it('should allow deleting a subname on the nameWrapper', async () => {
+    const wrapNameTx = await ENSInstance.wrapName(
+      'parthtejpal.eth',
+      accounts[0],
+    )
+    await wrapNameTx.wait()
+    const createSubnameTx = await ENSInstance.createSubname({
+      contract: 'nameWrapper',
+      name: 'test.parthtejpal.eth',
+      owner: accounts[0],
+      options: { addressOrIndex: 0 },
+    })
+    await createSubnameTx.wait()
+
+    const tx = await ENSInstance.deleteSubname(
+      'test.parthtejpal.eth',
+      'nameWrapper',
+      { addressOrIndex: 0 },
+    )
+    expect(tx).toBeTruthy()
+    await tx.wait()
+
+    const nameWrapper = await ENSInstance.contracts!.getNameWrapper()!
+    const result = await nameWrapper.ownerOf(namehash('test.parthtejpal.eth'))
+    expect(result).toBe('0x0000000000000000000000000000000000000000')
+  })
+})

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,
+  )
+}