@ensdomains/ensjs 2.1.0 → 3.0.0-alpha.11

package/src/GqlManager.ts

@@ -0,0 +1,83 @@
+// @ts-nocheck
+import { namehash } from './utils/normalise'
+
+const generateSelection = (selection: any) => ({
+  kind: 'Field',
+  name: {
+    kind: 'Name',
+    value: selection,
+  },
+  arguments: [],
+  directives: [],
+  alias: undefined,
+  selectionSet: undefined,
+})
+
+export const enter = (node: any) => {
+  if (node.kind === 'SelectionSet') {
+    const id = node.selections.find((x) => x.name && x.name.value === 'id')
+    const name = node.selections.find((x) => x.name && x.name.value === 'name')
+
+    if (!id && name) {
+      node.selections = [...node.selections, generateSelection('id')]
+      return node
+    }
+  }
+}
+
+export const requestMiddleware = (visit, parse) => (request: any) => {
+  const requestBody = JSON.parse(request.body)
+  const rawQuery = requestBody.query
+  const parsedQuery = parse(rawQuery)
+  const updatedQuery = visit(parsedQuery, { enter })
+  const updatedBody = { ...requestBody, query: updatedQuery.loc.source.body }
+
+  return {
+    ...request,
+    body: JSON.stringify(updatedBody),
+  }
+}
+
+export const responseMiddleware = (traverse) => (response: any) => {
+  traverse(response).forEach(function (responseItem: any) {
+    if (responseItem instanceof Object && responseItem.name) {
+      //Name already in hashed form
+      if (responseItem.name && responseItem.name.includes('[')) {
+        return
+      }
+
+      const hashedName = namehash(responseItem.name)
+      if (responseItem.id !== hashedName) {
+        this.update({ ...responseItem, name: hashedName, invalidName: true })
+      }
+    }
+  })
+  return response
+}
+
+export default class GqlManager {
+  public gql: any = () => null
+  public client?: any | null = null
+
+  public setUrl = async (url: string | null) => {
+    if (url) {
+      const [imported, traverse, { visit, parse }] = await Promise.all([
+        import('graphql-request'),
+        import('traverse'),
+        import('graphql/language'),
+      ])
+
+      this.client = new imported.GraphQLClient(url, {
+        requestMiddleware: requestMiddleware(visit, parse),
+        responseMiddleware: responseMiddleware(traverse.default),
+      })
+      this.gql = imported.gql
+    } else {
+      this.client = null
+      this.gql = () => null
+    }
+  }
+
+  public request = (...arg: any[]) =>
+    this.client ? this.client.request(...arg) : null
+}

package/src/contracts/baseRegistrar.ts

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

package/src/contracts/ethRegistrarController.ts

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

package/src/contracts/getContractAddress.ts

@@ -0,0 +1,52 @@
+import { ContractName, SupportedNetworkId } from './types'
+
+const addresses: Record<
+  ContractName,
+  Partial<Record<SupportedNetworkId, string>> | string
+> = {
+  BaseRegistrarImplementation: {
+    '1': '0x57f1887a8bf19b14fc0df6fd9b2acc9af147ea85',
+    '3': '0x57f1887a8bf19b14fc0df6fd9b2acc9af147ea85',
+    '4': '0x57f1887a8bf19b14fc0df6fd9b2acc9af147ea85',
+    '5': '0x57f1887a8bf19b14fc0df6fd9b2acc9af147ea85',
+  },
+  ETHRegistrarController: {
+    '1': '0x283af0b28c62c092c9727f1ee09c02ca627eb7f5',
+    '3': '0x283af0b28c62c092c9727f1ee09c02ca627eb7f5',
+    '4': '0x283af0b28c62c092c9727f1ee09c02ca627eb7f5',
+    '5': '0x283af0b28c62c092c9727f1ee09c02ca627eb7f5',
+  },
+  Multicall: '0xcA11bde05977b3631167028862bE2a173976CA11',
+  NameWrapper: '0x0000000000000000000000000000000000000000',
+  PublicResolver: {
+    '1': '0x4976fb03C32e5B8cfe2b6cCB31c09Ba78EBaBa41',
+  },
+  ENSRegistryWithFallback: {
+    '1': '0x00000000000c2e074ec69a0dfb2997ba6c7d2e1e',
+    '3': '0x00000000000c2e074ec69a0dfb2997ba6c7d2e1e',
+    '4': '0x00000000000c2e074ec69a0dfb2997ba6c7d2e1e',
+    '5': '0x00000000000c2e074ec69a0dfb2997ba6c7d2e1e',
+  },
+  ReverseRegistrar: {
+    '1': '0x084b1c3C81545d370f3634392De611CaaBFf8148',
+  },
+  UniversalResolver: {
+    '1': '0x580AF46E06DaaD47eb5940526FD64d95b815Cb70',
+    '4': '0x74e20bd2a1fe0cdbe45b9a1d89cb7e0a45b36376',
+  },
+}
+
+export type ContractAddressFetch = (contractName: ContractName) => string
+
+export const getContractAddress = (networkId: SupportedNetworkId) =>
+  ((contractName: ContractName) => {
+    try {
+      return typeof addresses[contractName] === 'string'
+        ? addresses[contractName]
+        : addresses[contractName][networkId]
+    } catch {
+      throw new Error(
+        `No address for contract ${contractName} on network ${networkId}`,
+      )
+    }
+  }) as ContractAddressFetch

package/src/contracts/index.ts

@@ -0,0 +1,68 @@
+import { ethers } from 'ethers'
+import getBaseRegistrar from './baseRegistrar'
+import getEthRegistrarController from './ethRegistrarController'
+import { ContractAddressFetch } from './getContractAddress'
+import getMulticall from './multicall'
+import getNameWrapper from './nameWrapper'
+import getPublicResolver from './publicResolver'
+import getRegistry from './registry'
+import getReverseRegistrar from './reverseRegistrar'
+import { ContractName } from './types'
+import getUniversalResolver from './universalResolver'
+
+export default class ContractManager {
+  private provider: ethers.providers.Provider
+  private fetchAddress: ContractAddressFetch
+
+  constructor(
+    provider: ethers.providers.Provider,
+    fetchAddress: ContractAddressFetch,
+  ) {
+    this.provider = provider
+    this.fetchAddress = fetchAddress
+  }
+
+  private generateContractGetter = <C extends (...args: any) => any>(
+    name: ContractName,
+    func: C,
+  ): ((passedProvider?: any, address?: string) => Promise<ReturnType<C>>) => {
+    return async (
+      passedProvider?: any,
+      address?: string,
+    ): Promise<ReturnType<C>> => {
+      const inputAddress = address || this.fetchAddress(name)
+      const provider = passedProvider || this.provider
+      return func(provider, inputAddress)
+    }
+  }
+
+  public getPublicResolver = this.generateContractGetter(
+    'PublicResolver',
+    getPublicResolver,
+  )
+  public getUniversalResolver = this.generateContractGetter(
+    'UniversalResolver',
+    getUniversalResolver,
+  )
+  public getRegistry = this.generateContractGetter(
+    'ENSRegistryWithFallback',
+    getRegistry,
+  )
+  public getReverseRegistrar = this.generateContractGetter(
+    'ReverseRegistrar',
+    getReverseRegistrar,
+  )
+  public getNameWrapper = this.generateContractGetter(
+    'NameWrapper',
+    getNameWrapper,
+  )
+  public getBaseRegistrar = this.generateContractGetter(
+    'BaseRegistrarImplementation',
+    getBaseRegistrar,
+  )
+  public getEthRegistrarController = this.generateContractGetter(
+    'ETHRegistrarController',
+    getEthRegistrarController,
+  )
+  public getMulticall = this.generateContractGetter('Multicall', getMulticall)
+}

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('with-profile.eth', 'description'),
+      ENSInstance.getAddr.batch('with-profile.eth'),
+      ENSInstance.getName.batch('0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC'),
+    )
+    expect(result).toBeTruthy()
+    if (result) {
+      expect(result[0]).toBe('Hello2')
+      expect(result[1]).toBe('0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC')
+      expect(result[2]).toMatchObject({
+        name: 'with-profile.eth',
+        match: true,
+      })
+    }
+  })
+  it('should batch a single call', async () => {
+    const result = await ENSInstance.batch(
+      ENSInstance.getText.batch('with-profile.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('with-profile.eth', 'description'),
+      await ENSInstance._getText.raw('with-profile.eth', 'url'),
+      await ENSInstance._getAddr.raw('with-profile.eth'),
+    ])
+    const universalResponse = await ENSInstance.universalWrapper(
+      'with-profile.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('0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC')
+  })
+})

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,40 @@
+import { ethers } from 'ethers'
+import { ENS } from '..'
+import setup from '../tests/setup'
+import { namehash } from '../utils/normalise'
+
+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 tx = await ENSInstance.burnFuses('wrapped.eth', {
+      fusesToBurn: {
+        cannotUnwrap: true,
+        cannotCreateSubdomain: true,
+        cannotSetTtl: true,
+      },
+      addressOrIndex: accounts[1],
+    })
+    expect(tx).toBeTruthy()
+    await tx.wait()
+
+    const nameWrapper = await ENSInstance.contracts!.getNameWrapper()!
+    const [fuses] = await nameWrapper.getFuses(namehash('wrapped.eth'))
+    expect(fuses).toBe(113)
+  })
+})

package/src/functions/burnFuses.ts

@@ -0,0 +1,21 @@
+import { ENSArgs } from '..'
+import { FuseOptions } from '../@types/FuseOptions'
+import generateFuseInput from '../utils/generateFuseInput'
+import { namehash } from '../utils/normalise'
+
+export default async function (
+  { contracts, signer }: ENSArgs<'contracts' | 'signer'>,
+  name: string,
+  {
+    fusesToBurn,
+  }: {
+    fusesToBurn: FuseOptions
+  },
+) {
+  const nameWrapper = (await contracts?.getNameWrapper()!).connect(signer)
+  const hash = namehash(name)
+
+  const encodedFuses = generateFuseInput(fusesToBurn)
+
+  return nameWrapper.populateTransaction.setFuses(hash, encodedFuses)
+}

package/src/functions/createSubname.test.ts

@@ -0,0 +1,51 @@
+import { ethers } from 'ethers'
+import { ENS } from '..'
+import setup from '../tests/setup'
+import { namehash } from '../utils/normalise'
+
+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('test.test123.eth', {
+      contract: 'registry',
+      owner: accounts[0],
+      addressOrIndex: 1,
+    })
+    expect(tx).toBeTruthy()
+    await tx.wait()
+
+    const registry = await ENSInstance.contracts!.getRegistry()!
+    const result = await registry.owner(namehash('test.test123.eth'))
+    expect(result).toBe(accounts[0])
+  })
+  it('should allow creating a subname on the namewrapper', async () => {
+    const tx = await ENSInstance.createSubname('test.wrapped.eth', {
+      contract: 'nameWrapper',
+      owner: accounts[0],
+      addressOrIndex: 1,
+    })
+    expect(tx).toBeTruthy()
+    await tx.wait()
+
+    const nameWrapper = await ENSInstance.contracts!.getNameWrapper()!
+    const result = await nameWrapper.ownerOf(namehash('test.wrapped.eth'))
+    expect(result).toBe(accounts[0])
+  })
+})