@ensdomains/ensjs 3.0.0-alpha.2 → 3.0.0-alpha.20

package/src/GqlManager.ts

@@ -1,11 +1,99 @@
+import type {
+  Kind,
+  parse as Parse,
+  print as Print,
+  SelectionSetNode,
+  visit as Visit,
+} from 'graphql'
+import type Traverse from 'traverse'
+import { namehash } from './utils/normalise'
+
+const generateSelection = (selection: any) => ({
+  kind: 'Field' as Kind.FIELD,
+  name: {
+    kind: 'Name' as Kind.NAME,
+    value: selection,
+  },
+  arguments: [],
+  directives: [],
+  alias: undefined,
+  selectionSet: undefined,
+})
+
+export const enter = (node: SelectionSetNode) => {
+  let hasName = false
+  let hasId = false
+
+  for (const selection of node.selections) {
+    if ('name' in selection) {
+      if (selection.name.value === 'name') hasName = true
+      else if (selection.name.value === 'id') hasId = true
+    }
+  }
+
+  if (hasName && !hasId) {
+    // eslint-disable-next-line no-param-reassign
+    node.selections = [...node.selections, generateSelection('id')]
+    return node
+  }
+}
+
+export const requestMiddleware =
+  (visit: typeof Visit, parse: typeof Parse, print: typeof Print) =>
+  (request: any) => {
+    const requestBody = JSON.parse(request.body)
+    const rawQuery = requestBody.query
+    const parsedQuery = parse(rawQuery)
+    const updatedQuery = visit(parsedQuery, {
+      // eslint-disable-next-line @typescript-eslint/naming-convention
+      SelectionSet: {
+        enter,
+      },
+    })
+
+    return {
+      ...request,
+      body: JSON.stringify({ ...requestBody, query: print(updatedQuery) }),
+    }
+  }
+
+export const responseMiddleware =
+  (traverse: typeof Traverse) => (response: any) => {
+    // eslint-disable-next-line func-names
+    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 {
+  // eslint-disable-next-line class-methods-use-this
   public gql: any = () => null
+
   public client?: any | null = null
 
   public setUrl = async (url: string | null) => {
     if (url) {
-      const imported = await import('graphql-request')
-      this.client = new imported.GraphQLClient(url)
+      const [imported, traverse, { visit, parse, print }] = await Promise.all([
+        import('graphql-request'),
+        import('traverse'),
+        import('graphql/language'),
+      ])
+
+      this.client = new imported.GraphQLClient(url, {
+        requestMiddleware: requestMiddleware(visit, parse, print),
+        responseMiddleware: responseMiddleware(traverse.default),
+      })
       this.gql = imported.gql
     } else {
       this.client = null

package/src/contracts/getContractAddress.ts

@@ -4,6 +4,7 @@ const addresses: Record<
   ContractName,
   Partial<Record<SupportedNetworkId, string>> | string
 > = {
+  /* eslint-disable @typescript-eslint/naming-convention */
   BaseRegistrarImplementation: {
     '1': '0x57f1887a8bf19b14fc0df6fd9b2acc9af147ea85',
     '3': '0x57f1887a8bf19b14fc0df6fd9b2acc9af147ea85',
@@ -34,6 +35,7 @@ const addresses: Record<
     '1': '0x580AF46E06DaaD47eb5940526FD64d95b815Cb70',
     '4': '0x74e20bd2a1fe0cdbe45b9a1d89cb7e0a45b36376',
   },
+  /* eslint-enable @typescript-eslint/naming-convention */
 }
 
 export type ContractAddressFetch = (contractName: ContractName) => string

package/src/contracts/index.ts

@@ -12,6 +12,7 @@ import getUniversalResolver from './universalResolver'
 
 export default class ContractManager {
   private provider: ethers.providers.Provider
+
   private fetchAddress: ContractAddressFetch
 
   constructor(
@@ -25,7 +26,7 @@ export default class ContractManager {
   private generateContractGetter = <C extends (...args: any) => any>(
     name: ContractName,
     func: C,
-  ) => {
+  ): ((passedProvider?: any, address?: string) => Promise<ReturnType<C>>) => {
     return async (
       passedProvider?: any,
       address?: string,
@@ -40,29 +41,36 @@ export default class ContractManager {
     '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

@@ -1,24 +1,5 @@
 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/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

@@ -5,11 +5,11 @@ const raw = async (
   ...items: BatchFunctionResult<RawFunction>[]
 ) => {
   const rawDataArr: { to: string; data: string }[] = await Promise.all(
-    items.map(({ args, raw }, i: number) => {
-      if (!raw) {
+    items.map(({ args, raw: rawRef }, i: number) => {
+      if (!rawRef) {
         throw new Error(`Function ${i} is not batchable`)
       }
-      return raw(...args)
+      return rawRef(...args)
     }),
   )
   return multicallWrapper.raw(rawDataArr)

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

@@ -58,7 +58,7 @@ export const resolverMulticallWrapper = {
 }
 
 export const multicallWrapper = {
-  raw: async function (
+  async raw(
     { contracts }: ENSArgs<'contracts'>,
     transactions: ethers.providers.TransactionRequest[],
     requireSuccess: boolean = false,
@@ -75,7 +75,7 @@ export const multicallWrapper = {
       ]),
     }
   },
-  decode: async function ({ contracts }: ENSArgs<'contracts'>, data: string) {
+  async decode({ contracts }: ENSArgs<'contracts'>, data: string) {
     if (!data) return
     const multicall = await contracts?.getMulticall()!
     try {

package/src/functions/burnFuses.test.ts

@@ -0,0 +1,148 @@
+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()
+  })
+  describe('Array', () => {
+    it('should return a burnFuses transaction from a named fuse array and succeed', async () => {
+      const tx = await ensInstance.burnFuses('wrapped.eth', {
+        namedFusesToBurn: [
+          'CANNOT_UNWRAP',
+          'CANNOT_CREATE_SUBDOMAIN',
+          'CANNOT_SET_TTL',
+        ],
+        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)
+    })
+    it('should return a burnFuses transaction from an unnamed fuse array and succeed', async () => {
+      const tx0 = await ensInstance.burnFuses('wrapped.eth', {
+        namedFusesToBurn: ['CANNOT_UNWRAP'],
+        addressOrIndex: accounts[1],
+      })
+      expect(tx0).toBeTruthy()
+      await tx0.wait()
+
+      const tx = await ensInstance.burnFuses('wrapped.eth', {
+        unnamedFusesToBurn: [128, 256, 512],
+        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(961)
+    })
+    it('should return a burnFuses transaction from both an unnamed and named fuse array and succeed', async () => {
+      const tx = await ensInstance.burnFuses('wrapped.eth', {
+        namedFusesToBurn: [
+          'CANNOT_UNWRAP',
+          'CANNOT_CREATE_SUBDOMAIN',
+          'CANNOT_SET_TTL',
+        ],
+        unnamedFusesToBurn: [128, 256, 512],
+        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(1009)
+    })
+    it('should throw an error when trying to burn a named fuse in an unnamed fuse array', async () => {
+      try {
+        await ensInstance.burnFuses('wrapped.eth', {
+          unnamedFusesToBurn: [64] as any,
+        })
+        expect(false).toBeTruthy()
+      } catch (e: any) {
+        expect(e.message).toBe(
+          '64 is not a valid unnamed fuse. If you are trying to burn a named fuse, use the namedFusesToBurn property.',
+        )
+      }
+    })
+    it('should throw an error when trying to burn an unnamed fuse in a named fuse array', async () => {
+      try {
+        await ensInstance.burnFuses('wrapped.eth', {
+          namedFusesToBurn: ['COOL_SWAG_FUSE'] as any,
+        })
+        expect(false).toBeTruthy()
+      } catch (e: any) {
+        expect(e.message).toBe('COOL_SWAG_FUSE is not a valid named fuse.')
+      }
+    })
+  })
+  describe('Number', () => {
+    it('should return a burnFuses transaction from a number and succeed', async () => {
+      const tx = await ensInstance.burnFuses('wrapped.eth', {
+        fuseNumberToBurn: 49,
+        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)
+    })
+    it('should throw an error if the number is too high', async () => {
+      try {
+        await ensInstance.burnFuses('wrapped.eth', {
+          fuseNumberToBurn: 4294967297,
+        })
+        expect(false).toBeTruthy()
+      } catch (e: any) {
+        expect(e.message).toBe(
+          'Fuse number must be limited to uint32, 4294967297 was too high.',
+        )
+      }
+    })
+    it('should throw an error if the number is too low', async () => {
+      try {
+        await ensInstance.burnFuses('wrapped.eth', {
+          fuseNumberToBurn: -1,
+        })
+        expect(false).toBeTruthy()
+      } catch (e: any) {
+        expect(e.message).toBe(
+          'Fuse number must be limited to uint32, -1 was too low.',
+        )
+      }
+    })
+    it('should throw an error if the number is not an integer', async () => {
+      try {
+        await ensInstance.burnFuses('wrapped.eth', {
+          fuseNumberToBurn: 7.5,
+        })
+        expect(false).toBeTruthy()
+      } catch (e: any) {
+        expect(e.message).toBe('Fuse number must be an integer, 7.5 was not.')
+      }
+    })
+  })
+})

package/src/functions/burnFuses.ts

@@ -1,23 +1,79 @@
 import { ENSArgs } from '..'
-import { FuseOptions } from '../@types/FuseOptions'
-import generateFuseInput from '../utils/generateFuseInput'
+import {
+  fuseEnum,
+  NamedFusesToBurn,
+  unnamedFuses,
+  UnnamedFuseValues,
+} from '../utils/fuses'
 import { namehash } from '../utils/normalise'
 
+export type FusePropsNamedArray = {
+  namedFusesToBurn: NamedFusesToBurn
+}
+
+export type FusePropsUnnamedArray = {
+  unnamedFusesToBurn: UnnamedFuseValues[]
+}
+
+export type FusePropsNumber = {
+  fuseNumberToBurn: number
+}
+
+export type FuseProps =
+  | (Partial<FusePropsNamedArray> & FusePropsUnnamedArray)
+  | (FusePropsNamedArray & Partial<FusePropsUnnamedArray>)
+  | FusePropsNumber
+
 export default async function (
-  { contracts, provider }: ENSArgs<'contracts' | 'provider'>,
+  { contracts, signer }: ENSArgs<'contracts' | 'signer'>,
   name: string,
-  fusesToBurn: FuseOptions,
+  props: FuseProps,
 ) {
-  const signer = provider?.getSigner()
+  const isNumber = 'fuseNumberToBurn' in props
+  const hasNamedArray = 'namedFusesToBurn' in props
+  const hasUnnamedArray = 'unnamedFusesToBurn' in props
 
-  if (!signer) {
-    throw new Error('No signer found')
+  let encodedFuses: number = 0
+
+  if (isNumber) {
+    if (props.fuseNumberToBurn > 2 ** 32 || props.fuseNumberToBurn < 1) {
+      throw new Error(
+        `Fuse number must be limited to uint32, ${
+          props.fuseNumberToBurn
+        } was too ${props.fuseNumberToBurn < 1 ? 'low' : 'high'}.`,
+      )
+    } else if (props.fuseNumberToBurn % 1 !== 0) {
+      throw new Error(
+        `Fuse number must be an integer, ${props.fuseNumberToBurn} was not.`,
+      )
+    }
+    encodedFuses = props.fuseNumberToBurn
+  } else {
+    if (!hasNamedArray && !hasUnnamedArray) {
+      throw new Error('Please provide fuses to burn')
+    }
+    if (hasNamedArray) {
+      for (const fuse of props.namedFusesToBurn!) {
+        if (!(fuse in fuseEnum)) {
+          throw new Error(`${fuse} is not a valid named fuse.`)
+        }
+        encodedFuses |= fuseEnum[fuse]
+      }
+    }
+    if (hasUnnamedArray) {
+      for (const fuse of props.unnamedFusesToBurn!) {
+        if (!unnamedFuses.includes(fuse)) {
+          throw new Error(
+            `${fuse} is not a valid unnamed fuse. If you are trying to burn a named fuse, use the namedFusesToBurn property.`,
+          )
+        }
+        encodedFuses |= fuse
+      }
+    }
   }
 
-  const nameWrapper = (await contracts?.getNameWrapper()!).connect(signer)
+  const nameWrapper = (await contracts!.getNameWrapper()!).connect(signer)
   const hash = namehash(name)
 
-  const encodedFuses = generateFuseInput(fusesToBurn)
-
-  return nameWrapper.burnFuses(hash, encodedFuses)
+  return nameWrapper.populateTransaction.setFuses(hash, encodedFuses)
 }

package/src/functions/commitName.test.ts

@@ -0,0 +1,61 @@
+import { ethers } from 'ethers'
+import { ENS } from '..'
+import setup from '../tests/setup'
+import { randomSecret } from '../utils/registerHelpers'
+
+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('commitName', () => {
+  beforeEach(async () => {
+    await revert()
+  })
+  it('should return a populated commit transaction with extra data and succeed', async () => {
+    const { customData, ...popTx } =
+      await ensInstance.commitName.populateTransaction('commitment.eth', {
+        duration: 31536000,
+        owner: accounts[1],
+        addressOrIndex: accounts[1],
+      })
+    expect(popTx).toBeTruthy()
+    expect(customData).toHaveProperty('secret')
+    expect(customData).toHaveProperty('commitment')
+    expect(customData).toHaveProperty('wrapperExpiry')
+
+    const tx = await provider.getSigner().sendTransaction(popTx)
+    await tx.wait()
+
+    const controller = await ensInstance.contracts!.getEthRegistrarController()!
+    const commitment = await controller.commitments(customData!.commitment)
+    expect(commitment).toBeTruthy()
+  })
+  it('should return a customised commmit transaction and succeed', async () => {
+    const secret = randomSecret()
+    const tx = await ensInstance.commitName('commitment.eth', {
+      duration: 31536000,
+      owner: accounts[1],
+      addressOrIndex: accounts[1],
+      secret,
+      wrapperExpiry: 100000,
+    })
+    await tx.wait()
+    expect(tx.customData).toBeTruthy()
+    expect(tx.customData!.wrapperExpiry).toBe(100000)
+    expect(tx.customData!.secret).toBe(secret)
+
+    const controller = await ensInstance.contracts!.getEthRegistrarController()!
+    const commitment = await controller.commitments(tx.customData!.commitment)
+    expect(commitment).toBeTruthy()
+  })
+})

package/src/functions/commitName.ts

@@ -0,0 +1,36 @@
+import { ENSArgs } from '..'
+import { CommitmentParams, makeCommitment } from '../utils/registerHelpers'
+
+type Params = Omit<CommitmentParams, 'resolver' | 'name'> & {
+  resolverAddress?: string
+}
+
+export default async function (
+  { contracts }: ENSArgs<'contracts'>,
+  name: string,
+  { resolverAddress, ...params }: Params,
+) {
+  const labels = name.split('.')
+  if (labels.length !== 2 || labels[1] !== 'eth')
+    throw new Error('Currently only .eth TLD registrations are supported')
+
+  const controller = await contracts!.getEthRegistrarController()
+  const resolver = await contracts!.getPublicResolver(
+    undefined,
+    resolverAddress,
+  )
+  const { secret, commitment, wrapperExpiry } = makeCommitment({
+    name,
+    resolver,
+    ...params,
+  })
+
+  return {
+    ...(await controller.populateTransaction.commit(commitment)),
+    customData: {
+      secret,
+      commitment,
+      wrapperExpiry,
+    },
+  }
+}