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

package/src/functions/getFuses.test.ts

@@ -0,0 +1,96 @@
+import { BigNumber } from 'ethers'
+import { ENS } from '..'
+import setup from '../tests/setup'
+
+let ensInstance: ENS
+let revert: Awaited<ReturnType<typeof setup>>['revert']
+let createSnapshot: Awaited<ReturnType<typeof setup>>['createSnapshot']
+let withWrappedSnapshot: any
+
+const unwrappedNameDefault = {
+  expiryDate: new Date(0).toString(),
+  fuseObj: {
+    CANNOT_BURN_FUSES: false,
+    CANNOT_CREATE_SUBDOMAIN: false,
+    CANNOT_SET_RESOLVER: false,
+    CANNOT_SET_TTL: false,
+    CANNOT_TRANSFER: false,
+    CANNOT_UNWRAP: false,
+    PARENT_CANNOT_CONTROL: false,
+    CAN_DO_EVERYTHING: true,
+  },
+  owner: '0x0000000000000000000000000000000000000000',
+  rawFuses: BigNumber.from(0),
+}
+
+beforeAll(async () => {
+  ;({ ensInstance, revert, createSnapshot } = await setup())
+
+  withWrappedSnapshot = await createSnapshot()
+})
+
+afterEach(async () => {
+  await revert(withWrappedSnapshot)
+  withWrappedSnapshot = await createSnapshot()
+})
+
+afterAll(async () => {
+  await revert()
+})
+
+describe('getFuses', () => {
+  it('should return default data for an unwrapped name', async () => {
+    const result = await ensInstance.getFuses('with-profile.eth')
+    expect({ ...result, expiryDate: result?.expiryDate.toString() }).toEqual(
+      unwrappedNameDefault,
+    )
+  })
+  it('should return with CAN_DO_EVERYTHING set to true for a name with no fuses burned', async () => {
+    const result = await ensInstance.getFuses('test.wrapped-with-subnames.eth')
+    expect(result).toBeTruthy()
+    if (result) {
+      expect(result.fuseObj.CAN_DO_EVERYTHING).toBe(true)
+      expect(
+        Object.values(result.fuseObj).reduce(
+          (prev, curr) => (curr ? prev + 1 : prev),
+          0,
+        ),
+      ).toBe(1)
+      expect(result.rawFuses.toHexString()).toBe('0x00')
+    }
+  })
+  it('should return with other correct fuses', async () => {
+    const tx = await ensInstance.burnFuses('wrapped.eth', {
+      namedFusesToBurn: [
+        'CANNOT_UNWRAP',
+        'CANNOT_CREATE_SUBDOMAIN',
+        'CANNOT_SET_TTL',
+      ],
+      addressOrIndex: 1,
+    })
+    await tx.wait()
+
+    const result = await ensInstance.getFuses('wrapped.eth')
+    expect(result).toBeTruthy()
+    if (result) {
+      expect(result.fuseObj).toMatchObject({
+        CANNOT_UNWRAP: true,
+        CANNOT_BURN_FUSES: false,
+        CANNOT_TRANSFER: false,
+        CANNOT_SET_RESOLVER: false,
+        CANNOT_SET_TTL: true,
+        CANNOT_CREATE_SUBDOMAIN: true,
+        PARENT_CANNOT_CONTROL: true,
+        CAN_DO_EVERYTHING: false,
+      })
+      expect(result.rawFuses.toHexString()).toBe('0x71')
+    }
+  })
+  it('should return correct expiry', async () => {
+    const result = await ensInstance.getFuses('wrapped.eth')
+    expect(result).toBeTruthy()
+    if (result) {
+      expect(result.expiryDate).toBeInstanceOf(Date)
+    }
+  })
+})

package/src/functions/getFuses.ts

@@ -1,71 +1,50 @@
-import { BigNumber, utils } from 'ethers'
+import { BigNumber } from 'ethers'
 import { ENSArgs } from '..'
-import { testable as fuseEnums } from '../utils/fuses'
+import { CurrentFuses, fuseEnum } from '../utils/fuses'
 import { namehash } from '../utils/normalise'
 
-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', [
-      namehash(name),
-    ]),
+    data: nameWrapper.interface.encodeFunctionData('getData', [namehash(name)]),
   }
 }
 
-const decode = async (
-  { contracts }: ENSArgs<'contracts'>,
-  data: string,
-  name: string,
-) => {
+const decode = async ({ contracts }: ENSArgs<'contracts'>, data: string) => {
   const nameWrapper = await contracts?.getNameWrapper()!
   try {
-    const [fuses, vulnerability, vulnerableNode] =
-      nameWrapper.interface.decodeFunctionResult('getFuses', data)
+    const {
+      owner,
+      fuses: _fuses,
+      expiry,
+    } = nameWrapper.interface.decodeFunctionResult('getData', data)
+
+    const fuses = BigNumber.from(_fuses)
 
     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),
+      Object.keys(fuseEnum).map((fuse) => [
+        fuse,
+        fuses.and(fuseEnum[fuse as keyof typeof fuseEnum]).gt(0),
       ]),
     )
 
     if (fuses.eq(0)) {
-      fuseObj.canDoEverything = true
+      fuseObj.CAN_DO_EVERYTHING = true
     } else {
-      fuseObj.canDoEverything = false
+      fuseObj.CAN_DO_EVERYTHING = 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 = namehash(node)
-        if (nodehash === vulnerableNode) {
-          returnVulnerableNode = node
-        }
-      })
-    }
+    const expiryDate = new Date(expiry * 1000)
 
     return {
-      fuseObj,
-      vulnerability: NameSafety[vulnerability] || vulnerability,
-      vulnerableNode: returnVulnerableNode,
-      rawFuses: fuses as BigNumber,
+      fuseObj: fuseObj as CurrentFuses,
+      expiryDate,
+      rawFuses: fuses,
+      owner,
     }
-  } catch {
+  } catch (e) {
+    console.error('Error decoding fuses data: ', e)
     return
   }
 }

package/src/functions/getHistory.test.ts

@@ -0,0 +1,29 @@
+import { ENS } from '..'
+import setup from '../tests/setup'
+
+let ensInstance: ENS
+let revert: Awaited<ReturnType<typeof setup>>['revert']
+
+beforeAll(async () => {
+  ;({ ensInstance, revert } = await setup())
+})
+
+afterAll(async () => {
+  await revert()
+})
+
+describe('getHistory', () => {
+  it('should return null for a non-existent name', async () => {
+    const result = await ensInstance.getHistory('test123123cool.eth')
+    expect(result).toBeUndefined()
+  })
+  it('should return the history of a name', async () => {
+    const result = await ensInstance.getHistory('with-profile.eth')
+    expect(result).toBeTruthy()
+    if (result) {
+      expect(result).toHaveProperty('domain')
+      expect(result).toHaveProperty('resolver')
+      expect(result).toHaveProperty('registration')
+    }
+  })
+})

package/src/functions/getHistory.ts

@@ -2,7 +2,6 @@ import { formatsByCoinType } from '@ensdomains/address-encoder'
 import { ethers } from 'ethers'
 import { ENSArgs } from '..'
 import { decodeContenthash } from '../utils/contentHash'
-import { makeOtherIndexes } from '../utils/makeHashIndexes'
 
 type DomainEvent = 'NewOwner' | 'NewResolver' | 'Transfer' | 'NewTTL'
 type RegistrationEvent = 'NameRegistered' | 'NameRenewed' | 'NameTransferred'
@@ -18,11 +17,15 @@ type ResolverEvent =
   | 'AuthorisationChanged'
 
 type EventTypes = 'Domain' | 'Registration' | 'Resolver'
+type EventFormat = {
+  Domain: DomainEvent
+  Registration: RegistrationEvent
+  Resolver: ResolverEvent
+}
 
-const eventFormat: Record<
-  EventTypes,
-  Record<string, (args: any) => Record<string, any>>
-> = {
+const eventFormat: {
+  [key in EventTypes]: { [n in EventFormat[key]]: (args: any) => object }
+} = {
   Domain: {
     NewOwner: (args: any) => ({ owner: args.owner.id }),
     NewResolver: (args: any) => ({ resolver: args.resolver.id.split('-')[0] }),
@@ -63,7 +66,7 @@ const eventFormat: Record<
     NameChanged: (args: any) => ({ name: args.name }),
     AbiChanged: (args: any) => ({ contentType: args.contentType }),
     PubkeyChanged: (args: any) => ({ x: args.x, y: args.y }),
-    TextChanged: (args: any) => ({ key: args.key }),
+    TextChanged: (args: any) => ({ key: args.key, value: args.value }),
     ContenthashChanged: (args: any) => ({ hash: decodeContenthash(args.hash) }),
     InterfaceChanged: (args: any) => ({
       interfaceId: args.interfaceId,
@@ -77,51 +80,27 @@ const eventFormat: Record<
   },
 }
 
-const mapEvents = (eventArray: any[], type: EventTypes) =>
-  eventArray.map((event: any) => ({
-    type: event.__typename,
-    blockNumber: event.blockNumber,
-    transactionHash: event.transactionID,
-    id: event.id,
-    data: eventFormat[type][event.__typename](event),
-  }))
-
-const mapResultDetailDecode =
-  (publicResolver: ethers.Contract) => (result: any) => {
-    const hashIndexes = makeOtherIndexes(result.input, '10f13a8c')
-    const abiLengths = hashIndexes.map((x: number) => ({
-      index: x,
-      length:
-        x === 0
-          ? ethers.utils.hexDataLength(result.input)
-          : parseInt(ethers.utils.hexDataSlice(result.input, x - 32, x), 16),
-    }))
-    const ABIs = abiLengths.map(({ index, length }) =>
-      ethers.utils.hexDataSlice(result.input, index, index + length),
-    )
-    return ABIs.map((abi: string) => {
-      try {
-        return publicResolver.interface.decodeFunctionData(
-          'setText(bytes32,string,string)',
-          abi,
-        )
-      } catch {
-        return
-      }
-    })
-  }
-
-const expandDecode = (prev: any, curr: any) => {
-  if (!curr) return [...prev, { value: null }]
-  if (!curr.length) return [...prev, curr]
-  return [...prev, ...curr]
-}
+const mapEvents = <T extends EventTypes>(eventArray: any[], type: T) =>
+  eventArray.map(
+    (event: {
+      __typename: EventFormat[T]
+      blockNumber: number
+      transactionID: string
+      id: string
+    }) => ({
+      type: event.__typename,
+      blockNumber: event.blockNumber,
+      transactionHash: event.transactionID,
+      id: event.id,
+      data: eventFormat[type][event.__typename](event),
+    }),
+  )
 
 export async function getHistory(
   { gqlInstance }: ENSArgs<'gqlInstance'>,
   name: string,
 ) {
-  const client = gqlInstance.client
+  const { client } = gqlInstance
   const query = gqlInstance.gql`
       query getHistory($name: String!, $label: String!) {
         domains(where: { name: $name }) {
@@ -200,6 +179,7 @@ export async function getHistory(
               }
               ...on TextChanged {
                 key
+                value
               }
               ...on ContenthashChanged {
                 hash
@@ -237,7 +217,7 @@ export async function getHistory(
 
   const domainHistory = mapEvents(domainEvents, 'Domain')
   const registrationHistory = mapEvents(registrationEvents, 'Registration')
-  let resolverHistory = mapEvents(
+  const resolverHistory = mapEvents(
     // remove duplicate events for ETH cointype
     resolverEvents.filter(
       (event: any) => !event.coinType || event.coinType !== '60',
@@ -251,97 +231,3 @@ export async function getHistory(
     resolver: resolverHistory,
   }
 }
-
-export async function getHistoryWithDetail(
-  {
-    contracts,
-    gqlInstance,
-    provider,
-  }: ENSArgs<'contracts' | 'gqlInstance' | 'provider'>,
-  name: string,
-) {
-  const historyRes = await getHistory({ gqlInstance }, name)
-
-  if (!historyRes) return
-
-  const { domain, registration, resolver: resolverHistory } = historyRes
-
-  const textEvents = resolverHistory.filter(
-    (event) => event.type === 'TextChanged',
-  )
-
-  const transactions = textEvents.reduce((prev, curr) => {
-    if (prev.includes(curr.transactionHash)) {
-      return prev
-    }
-    return [...prev, curr.transactionHash]
-  }, [] as string[])
-
-  const publicResolver = await contracts?.getPublicResolver()!
-
-  const fetchResult = (
-    await ethers.utils.fetchJson(
-      provider!.connection,
-      JSON.stringify(
-        transactions.map((tx, i) => ({
-          jsonrpc: '2.0',
-          id: i,
-          method: 'eth_getTransactionByHash',
-          params: [tx],
-        })),
-      ),
-    )
-  )
-    .map((result: any) => result.result)
-    .map(mapResultDetailDecode(publicResolver))
-    .reduce(expandDecode, [])
-
-  const detailedResolverHistory = resolverHistory.map((event) => {
-    if (event.type !== 'TextChanged') return event
-    const { id } = event
-    const matchedTextInx = textEvents.findIndex((x) => x.id === id)
-    return {
-      ...event,
-      data: {
-        ...event.data,
-        value: fetchResult[matchedTextInx] && fetchResult[matchedTextInx].value,
-      },
-    }
-  })
-
-  return {
-    domain,
-    registration,
-    resolver: detailedResolverHistory,
-  }
-}
-
-export async function getHistoryDetailForTransactionHash(
-  { contracts, provider }: ENSArgs<'contracts' | 'provider'>,
-  hash: string,
-  indexInTransaction?: number,
-) {
-  const publicResolver = await contracts?.getPublicResolver()!
-  const transaction = await provider!.getTransaction(hash)
-  if (!transaction) return
-  const result = mapResultDetailDecode(publicResolver)({
-    input: transaction.data,
-  })
-  if (!result || !result.length) return
-  if (typeof indexInTransaction === 'number') {
-    if (indexInTransaction + 1 > result.length) return
-    const resultItem = result[indexInTransaction]
-    if (
-      !resultItem ||
-      !resultItem.key ||
-      (!resultItem.value && resultItem.value !== '')
-    )
-      return
-    return { key: resultItem.key, value: resultItem.value }
-  }
-  return result.map((item: any) => {
-    if (!item.key) return
-    if (!item.value && item.value !== '') return { key: item.key, value: null }
-    return { key: item.key, value: item.value }
-  })
-}

package/src/{tests → functions}/getName.test.ts

@@ -1,14 +1,14 @@
 import { ethers } from 'ethers'
 import { ENS } from '..'
-import setup from './setup'
+import setup from '../tests/setup'
 
-let ENSInstance: ENS
+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())
+  ;({ ensInstance, revert, provider } = await setup())
   accounts = await provider.listAccounts()
 })
 
@@ -18,29 +18,29 @@ afterAll(async () => {
 
 describe('getName', () => {
   it('should get a primary name from an address', async () => {
-    const result = await ENSInstance.getName(
-      '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+    const result = await ensInstance.getName(
+      '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
     )
     expect(result).toBeTruthy()
     if (result) {
-      expect(result.name).toBe('jefflau.eth')
+      expect(result.name).toBe('with-profile.eth')
       expect(result.match).toBeTruthy()
     }
   })
   it('should return null for an address with no primary name', async () => {
-    const result = await ENSInstance.getName(
+    const result = await ensInstance.getName(
       '0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0',
     )
-    expect(result).toBeUndefined()
+    expect(result?.name).toBeUndefined()
   })
   it('should return with a false match for a name with no forward resolution', async () => {
-    const tx = await ENSInstance.setName('jefflau.eth')
+    const tx = await ensInstance.setName('with-profile.eth')
     await tx?.wait()
 
-    const result = await ENSInstance.getName(accounts[0])
+    const result = await ensInstance.getName(accounts[0])
     expect(result).toBeTruthy()
     if (result) {
-      expect(result.name).toBe('jefflau.eth')
+      expect(result.name).toBe('with-profile.eth')
       expect(result.match).toBeFalsy()
     }
   })

package/src/functions/getName.ts

@@ -3,7 +3,7 @@ import { hexEncodeName } from '../utils/hexEncodedName'
 
 const raw = async ({ contracts }: ENSArgs<'contracts'>, address: string) => {
   const universalResolver = await contracts?.getUniversalResolver()!
-  const reverseNode = address.toLowerCase().substring(2) + '.addr.reverse'
+  const reverseNode = `${address.toLowerCase().substring(2)}.addr.reverse`
   return {
     to: universalResolver.address,
     data: universalResolver.interface.encodeFunctionData('reverse', [
@@ -31,7 +31,7 @@ const decode = async (
       resolverAddress: result['3'],
     }
   } catch {
-    return { name: null, match: false }
+    return { name: undefined }
   }
 }