@ensdomains/ensjs 3.0.0-alpha.6 → 3.0.0-alpha.60

package/src/functions/getHistory.test.ts

@@ -1,22 +1,24 @@
 import { ENS } from '..'
 import setup from '../tests/setup'
 
-let ENSInstance: ENS
+let ensInstance: ENS
+let revert: Awaited<ReturnType<typeof setup>>['revert']
 
 beforeAll(async () => {
-  ;({ ENSInstance } = await setup())
-  jest.setTimeout(20000)
+  ;({ ensInstance, revert } = await setup())
 })
 
-describe('getHistory', () => {
-  let textEventsWithValue: any[]
+afterAll(async () => {
+  await revert()
+})
 
+describe('getHistory', () => {
   it('should return null for a non-existent name', async () => {
-    const result = await ENSInstance.getHistory('test123123cool.eth')
+    const result = await ensInstance.getHistory('test123123cool.eth')
     expect(result).toBeUndefined()
   })
   it('should return the history of a name', async () => {
-    const result = await ENSInstance.getHistory('jefflau.eth')
+    const result = await ensInstance.getHistory('with-profile.eth')
     expect(result).toBeTruthy()
     if (result) {
       expect(result).toHaveProperty('domain')
@@ -24,78 +26,24 @@ describe('getHistory', () => {
       expect(result).toHaveProperty('registration')
     }
   })
-  describe('getHistoryWithDetail', () => {
-    it('should return null for a non-existent name', async () => {
-      const result = await ENSInstance.getHistoryWithDetail(
-        'test123123cool.eth',
-      )
-      expect(result).toBeUndefined()
-    })
-    it('should return the history of a name with TextChanged event detail', async () => {
-      const result = await ENSInstance.getHistoryWithDetail('jefflau.eth')
-      expect(result).toBeTruthy()
-      if (result) {
-        const textEvents = result.resolver.filter(
-          (x) => x.type === 'TextChanged',
-        )
-        textEvents.forEach((event) =>
-          expect(event.data).toHaveProperty('value'),
-        )
-        textEventsWithValue = textEvents
-      }
-    })
+  it('should return the history of a wrapped name', async () => {
+    const result = await ensInstance.getHistory('wrapped.eth')
+    expect(result).toBeTruthy()
+    if (result) {
+      expect(result).toHaveProperty('domain')
+      expect(result).toHaveProperty('resolver')
+      expect(result).toHaveProperty('registration')
+    }
   })
-  describe('getHistoryDetailForTransactionHash', () => {
-    it('should throw an error for an invalid transaction hash', async () => {
-      try {
-        await ENSInstance.getHistoryDetailForTransactionHash('0x234')
-        expect(false).toBeTruthy()
-      } catch (error) {
-        expect((error as any).message).toContain('invalid hash')
-      }
-    })
-    it('should return null for a transaction hash with no text events', async () => {
-      const result = await ENSInstance.getHistoryDetailForTransactionHash(
-        '0x0fd7b555e3076ef38dbbe2e40deefe44c9a0530d43f6b3f60dbed4ba49d229b7',
-      )
-      expect(result).toBeUndefined()
-    })
-    it('should return single item for a given transaction hash with one event', async () => {
-      const eventToUse = textEventsWithValue[0]
-      const result = (await ENSInstance.getHistoryDetailForTransactionHash(
-        eventToUse.transactionHash,
-      )) as { key: any; value: any }[]
-      expect(result).toHaveLength(1)
-      if (result) {
-        expect(result[0]).toMatchObject(eventToUse.data)
-      }
-    })
-    it('should return multiple items for a given transaction hash with multiple events', async () => {
-      const hash =
-        '0x002b7cc3c85168d885a38226a28fac349d13cbaff7f3db4fa3af31f22b863079'
-      const dataArr = [
-        { key: 'description', value: 'Not so super description' },
-        { key: 'url', value: 'facebook.com' },
-      ]
-      const result = (await ENSInstance.getHistoryDetailForTransactionHash(
-        hash,
-      )) as { key: any; value: any }[]
-      expect(result).toHaveLength(dataArr.length)
-      if (result) {
-        result.forEach((item, index) =>
-          expect(item).toMatchObject(dataArr[index]),
-        )
-      }
-    })
-    it('should return a single item when an index is specified for a hash', async () => {
-      const hash =
-        '0x002b7cc3c85168d885a38226a28fac349d13cbaff7f3db4fa3af31f22b863079'
-      const data = { key: 'url', value: 'facebook.com' }
-      const result = (await ENSInstance.getHistoryDetailForTransactionHash(
-        hash,
-        1,
-      )) as { key: any; value: any }
-      expect(result).toMatchObject(data)
-    })
+  it('should return the history of a subname', async () => {
+    const result = await ensInstance.getHistory(
+      'test.wrapped-with-subnames.eth',
+    )
+    expect(result).toBeTruthy()
+    if (result) {
+      expect(result).toHaveProperty('domain')
+      expect(result).toHaveProperty('resolver')
+      expect(result).not.toHaveProperty('registration')
+    }
   })
 })

package/src/functions/getHistory.ts

@@ -1,10 +1,44 @@
 import { formatsByCoinType } from '@ensdomains/address-encoder'
-import { ethers } from 'ethers'
+import { hexStripZeros } from '@ethersproject/bytes'
 import { ENSArgs } from '..'
 import { decodeContenthash } from '../utils/contentHash'
-import { makeOtherIndexes } from '../utils/makeHashIndexes'
+import { namehash } from '../utils/normalise'
+import {
+  AbiChanged,
+  AddrChanged,
+  AuthorisationChanged,
+  ContenthashChanged,
+  ExpiryExtended,
+  FusesSet,
+  InterfaceChanged,
+  MulticoinAddrChanged,
+  NameChanged,
+  NameRegistered,
+  NameRenewed,
+  NameTransferred,
+  NameUnwrapped,
+  NameWrapped,
+  NewOwner,
+  NewResolver,
+  NewTtl,
+  PubkeyChanged,
+  TextChanged,
+  Transfer,
+  VersionChanged,
+  WrappedTransfer,
+} from '../utils/subgraph-types'
+import { checkIsDotEth } from '../utils/validation'
 
-type DomainEvent = 'NewOwner' | 'NewResolver' | 'Transfer' | 'NewTTL'
+type DomainEvent =
+  | 'NewOwner'
+  | 'NewResolver'
+  | 'Transfer'
+  | 'NewTTL'
+  | 'WrappedTransfer'
+  | 'NameWrapped'
+  | 'NameUnwrapped'
+  | 'FusesSet'
+  | 'ExpiryExtended'
 type RegistrationEvent = 'NameRegistered' | 'NameRenewed' | 'NameTransferred'
 type ResolverEvent =
   | 'AddrChanged'
@@ -16,30 +50,48 @@ type ResolverEvent =
   | 'ContenthashChanged'
   | 'InterfaceChanged'
   | 'AuthorisationChanged'
+  | 'VersionChanged'
 
 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] }),
-    Transfer: (args: any) => ({ owner: args.owner.id }),
-    NewTTL: (args: any) => ({ ttl: args.ttl }),
+    NewOwner: (args: NewOwner) => ({ owner: args.owner.id }),
+    NewResolver: (args: NewResolver) => ({
+      resolver: args.resolver.id.split('-')[0],
+    }),
+    Transfer: (args: Transfer) => ({ owner: args.owner.id }),
+    NewTTL: (args: NewTtl) => ({ ttl: args.ttl }),
+    WrappedTransfer: (args: WrappedTransfer) => ({ owner: args.owner.id }),
+    NameWrapped: (args: NameWrapped) => ({
+      fuses: args.fuses,
+      owner: args.owner.id,
+      expiryDate: args.expiryDate,
+    }),
+    NameUnwrapped: (args: NameUnwrapped) => ({ owner: args.owner.id }),
+    FusesSet: (args: FusesSet) => ({ fuses: args.fuses }),
+    ExpiryExtended: (args: ExpiryExtended) => ({ expiryDate: args.expiryDate }),
   },
   Registration: {
-    NameRegistered: (args: any) => ({
+    NameRegistered: (args: NameRegistered) => ({
       registrant: args.registrant.id,
       expiryDate: args.expiryDate,
     }),
-    NameRenewed: (args: any) => ({ expiryDate: args.expiryDate }),
-    NameTransferred: (args: any) => ({ owner: args.newOwner.id }),
+    NameRenewed: (args: NameRenewed) => ({ expiryDate: args.expiryDate }),
+    NameTransferred: (args: NameTransferred) => ({ owner: args.newOwner.id }),
   },
   Resolver: {
-    AddrChanged: (args: any) => ({ addr: args.addr.id }),
-    MulticoinAddrChanged: (args: any) => {
+    AddrChanged: (args: AddrChanged) => ({ addr: args.addr.id }),
+    MulticoinAddrChanged: (
+      args: Omit<MulticoinAddrChanged, 'addr'> & { multiaddr: string },
+    ) => {
       const format = formatsByCoinType[parseInt(args.coinType)]
       if (!format) {
         return {
@@ -47,7 +99,7 @@ const eventFormat: Record<
           rawAddr: args.multiaddr,
         }
       }
-      if (ethers.utils.hexStripZeros(args.multiaddr) === '0x') {
+      if (hexStripZeros(args.multiaddr) === '0x') {
         return {
           coinType: args.coinType,
           coinName: format.name,
@@ -60,71 +112,50 @@ const eventFormat: Record<
         addr: format.encoder(Buffer.from(args.multiaddr.slice(2), 'hex')),
       }
     },
-    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 }),
-    ContenthashChanged: (args: any) => ({ hash: decodeContenthash(args.hash) }),
-    InterfaceChanged: (args: any) => ({
-      interfaceId: args.interfaceId,
+    NameChanged: (args: NameChanged) => ({ name: args.name }),
+    AbiChanged: (args: AbiChanged) => ({ contentType: args.contentType }),
+    PubkeyChanged: (args: PubkeyChanged) => ({ x: args.x, y: args.y }),
+    TextChanged: (args: TextChanged) => ({ key: args.key, value: args.value }),
+    ContenthashChanged: (args: ContenthashChanged) => ({
+      hash: decodeContenthash(args.hash),
+    }),
+    InterfaceChanged: (args: InterfaceChanged) => ({
+      interfaceId: args.interfaceID,
       implementer: args.implementer,
     }),
-    AuthorisationChanged: (args: any) => ({
+    AuthorisationChanged: (args: AuthorisationChanged) => ({
       owner: args.owner,
       target: args.target,
       isAuthorized: args.isAuthorized,
     }),
+    VersionChanged: (args: VersionChanged) => ({ version: args.version }),
   },
 }
 
-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 }) {
+      query getHistory($namehash: String!) {
+        domain(id: $namehash) {
           events {
             id
             blockNumber
@@ -148,27 +179,48 @@ export async function getHistory(
             ...on NewTTL {
               ttl
             }
-          }
-          owner {
-            registrations (where: { labelName: $label }) {
-              events {
+            ...on WrappedTransfer {
+              owner {
                 id
-                blockNumber
-                transactionID
-                __typename
-                ...on NameRegistered {
-                  registrant {
-                    id
-                  }
-                  expiryDate
-                }
-                ...on NameRenewed {
-                  expiryDate
+              }
+            }
+            ...on NameWrapped {
+              fuses
+              expiryDate
+              owner {
+                id
+              }
+            }
+            ...on NameUnwrapped {
+              owner {
+                id
+              }
+            }
+            ...on FusesSet {
+              fuses
+            }
+            ...on ExpiryExtended {
+              expiryDate
+            }
+          }
+          registration {
+            events {
+              id
+              blockNumber
+              transactionID
+              __typename
+              ...on NameRegistered {
+                registrant {
+                  id
                 }
-                ...on NameTransferred {
-                  newOwner {
-                    id
-                  }
+                expiryDate
+              }
+              ...on NameRenewed {
+                expiryDate
+              }
+              ...on NameTransferred {
+                newOwner {
+                  id
                 }
               }
             }
@@ -200,6 +252,7 @@ export async function getHistory(
               }
               ...on TextChanged {
                 key
+                value
               }
               ...on ContenthashChanged {
                 hash
@@ -213,31 +266,33 @@ export async function getHistory(
                 target
                 isAuthorized
               }
+              ...on VersionChanged {
+                version
+              }
             }
           }
         }
       }
       `
 
-  const label = name.split('.')[0]
+  const nameHash = namehash(name)
+  const labels = name.split('.')
+  const is2ldEth = checkIsDotEth(labels)
 
-  const { domains } = await client.request(query, { name, label })
+  const response = await client.request(query, {
+    namehash: nameHash,
+  })
+  const domain = response?.domain
 
-  if (!domains || domains.length === 0) return
+  if (!domain) return
 
-  const [
-    {
-      events: domainEvents,
-      owner: {
-        registrations: [{ events: registrationEvents }],
-      },
-      resolver: { events: resolverEvents },
-    },
-  ] = domains
+  const {
+    events: domainEvents,
+    resolver: { events: resolverEvents },
+  } = domain
 
   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',
@@ -245,103 +300,20 @@ export async function getHistory(
     'Resolver',
   )
 
-  return {
-    domain: domainHistory,
-    registration: registrationHistory,
-    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)
+  if (is2ldEth) {
+    const {
+      registration: { events: registrationEvents },
+    } = domain
+    const registrationHistory = mapEvents(registrationEvents, 'Registration')
     return {
-      ...event,
-      data: {
-        ...event.data,
-        value: fetchResult[matchedTextInx] && fetchResult[matchedTextInx].value,
-      },
+      domain: domainHistory,
+      registration: registrationHistory,
+      resolver: resolverHistory,
     }
-  })
-
-  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 {
+    domain: domainHistory,
+    resolver: resolverHistory,
   }
-  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/functions/getName.test.ts

@@ -2,13 +2,13 @@ import { ethers } from 'ethers'
 import { ENS } from '..'
 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,10 +3,10 @@ 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', [
+    data: universalResolver.interface.encodeFunctionData('reverse(bytes)', [
       hexEncodeName(reverseNode),
     ]),
   }
@@ -21,7 +21,7 @@ const decode = async (
   const universalResolver = await contracts?.getUniversalResolver()!
   try {
     const result = universalResolver.interface.decodeFunctionResult(
-      'reverse',
+      'reverse(bytes)',
       data,
     )
     return {
@@ -31,7 +31,7 @@ const decode = async (
       resolverAddress: result['3'],
     }
   } catch {
-    return { name: null, match: false }
+    return { name: undefined }
   }
 }