@ensdomains/ensjs 2.1.0 → 3.0.0-alpha.11

package/src/functions/getHistory.test.ts

@@ -0,0 +1,113 @@
+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', () => {
+  let textEventsWithValue: any[]
+
+  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')
+    }
+  })
+  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('with-profile.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
+      }
+    })
+  })
+  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)
+      }
+    })
+    let hash: string = ''
+    it('should return multiple items for a given transaction hash with multiple events', async () => {
+      const dataArr = [
+        { key: 'foo', value: 'bar' },
+        { key: 'swag', value: 'cool' },
+      ]
+      const tx = await ENSInstance.setRecords('test123.eth', {
+        records: {
+          texts: dataArr,
+        },
+        addressOrIndex: 1,
+      })
+      await tx.wait()
+
+      hash = tx.hash
+
+      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 data = { key: 'swag', value: 'cool' }
+
+      const result = (await ENSInstance.getHistoryDetailForTransactionHash(
+        hash,
+        1,
+      )) as { key: any; value: any }
+      expect(result).toMatchObject(data)
+    })
+  })
+})

package/src/functions/getHistory.ts

@@ -0,0 +1,347 @@
+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'
+type ResolverEvent =
+  | 'AddrChanged'
+  | 'MulticoinAddrChanged'
+  | 'NameChanged'
+  | 'AbiChanged'
+  | 'PubkeyChanged'
+  | 'TextChanged'
+  | 'ContenthashChanged'
+  | 'InterfaceChanged'
+  | 'AuthorisationChanged'
+
+type EventTypes = 'Domain' | 'Registration' | 'Resolver'
+
+const eventFormat: Record<
+  EventTypes,
+  Record<string, (args: any) => Record<string, any>>
+> = {
+  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 }),
+  },
+  Registration: {
+    NameRegistered: (args: any) => ({
+      registrant: args.registrant.id,
+      expiryDate: args.expiryDate,
+    }),
+    NameRenewed: (args: any) => ({ expiryDate: args.expiryDate }),
+    NameTransferred: (args: any) => ({ owner: args.newOwner.id }),
+  },
+  Resolver: {
+    AddrChanged: (args: any) => ({ addr: args.addr.id }),
+    MulticoinAddrChanged: (args: any) => {
+      const format = formatsByCoinType[parseInt(args.coinType)]
+      if (!format) {
+        return {
+          coinType: args.coinType,
+          rawAddr: args.multiaddr,
+        }
+      }
+      if (ethers.utils.hexStripZeros(args.multiaddr) === '0x') {
+        return {
+          coinType: args.coinType,
+          coinName: format.name,
+          rawAddr: '0x',
+        }
+      }
+      return {
+        coinType: args.coinType,
+        coinName: format.name,
+        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,
+      implementer: args.implementer,
+    }),
+    AuthorisationChanged: (args: any) => ({
+      owner: args.owner,
+      target: args.target,
+      isAuthorized: args.isAuthorized,
+    }),
+  },
+}
+
+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]
+}
+
+export async function getHistory(
+  { gqlInstance }: ENSArgs<'gqlInstance'>,
+  name: string,
+) {
+  const client = gqlInstance.client
+  const query = gqlInstance.gql`
+      query getHistory($name: String!, $label: String!) {
+        domains(where: { name: $name }) {
+          events {
+            id
+            blockNumber
+            transactionID
+            __typename
+            ...on Transfer {
+              owner {
+                id
+              }
+            }
+            ...on NewOwner {
+              owner {
+                id
+              }
+            }
+            ...on NewResolver {
+              resolver {
+                id
+              }
+            }
+            ...on NewTTL {
+              ttl
+            }
+          }
+          owner {
+            registrations (where: { labelName: $label }) {
+              events {
+                id
+                blockNumber
+                transactionID
+                __typename
+                ...on NameRegistered {
+                  registrant {
+                    id
+                  }
+                  expiryDate
+                }
+                ...on NameRenewed {
+                  expiryDate
+                }
+                ...on NameTransferred {
+                  newOwner {
+                    id
+                  }
+                }
+              }
+            }
+          }
+          resolver {
+            events {
+              id
+              blockNumber
+              transactionID
+              __typename
+              ...on AddrChanged {
+                addr {
+                  id
+                }
+              }
+              ...on MulticoinAddrChanged {
+                coinType
+                multiaddr: addr
+              }
+              ...on NameChanged {
+                name
+              }
+              ...on AbiChanged {
+                contentType
+              }
+              ...on PubkeyChanged {
+                x
+                y
+              }
+              ...on TextChanged {
+                key
+              }
+              ...on ContenthashChanged {
+                hash
+              }
+              ...on InterfaceChanged {
+                interfaceID
+                implementer
+              }
+              ...on AuthorisationChanged {
+                owner
+                target
+                isAuthorized
+              }
+            }
+          }
+        }
+      }
+      `
+
+  const label = name.split('.')[0]
+
+  const { domains } = await client.request(query, { name, label })
+
+  if (!domains || domains.length === 0) return
+
+  const [
+    {
+      events: domainEvents,
+      owner: {
+        registrations: [{ events: registrationEvents }],
+      },
+      resolver: { events: resolverEvents },
+    },
+  ] = domains
+
+  const domainHistory = mapEvents(domainEvents, 'Domain')
+  const registrationHistory = mapEvents(registrationEvents, 'Registration')
+  let resolverHistory = mapEvents(
+    // remove duplicate events for ETH cointype
+    resolverEvents.filter(
+      (event: any) => !event.coinType || event.coinType !== '60',
+    ),
+    '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)
+    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/functions/getName.test.ts

@@ -0,0 +1,47 @@
+import { ethers } from 'ethers'
+import { ENS } from '..'
+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('getName', () => {
+  it('should get a primary name from an address', async () => {
+    const result = await ENSInstance.getName(
+      '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
+    )
+    expect(result).toBeTruthy()
+    if (result) {
+      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(
+      '0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0',
+    )
+    expect(result).toBeUndefined()
+  })
+  it('should return with a false match for a name with no forward resolution', async () => {
+    const tx = await ENSInstance.setName('with-profile.eth')
+    await tx?.wait()
+
+    const result = await ENSInstance.getName(accounts[0])
+    expect(result).toBeTruthy()
+    if (result) {
+      expect(result.name).toBe('with-profile.eth')
+      expect(result.match).toBeFalsy()
+    }
+  })
+})

package/src/functions/getName.ts

@@ -0,0 +1,41 @@
+import { ENSArgs } from '..'
+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'
+  return {
+    to: universalResolver.address,
+    data: universalResolver.interface.encodeFunctionData('reverse', [
+      hexEncodeName(reverseNode),
+    ]),
+  }
+}
+
+const decode = async (
+  { contracts }: ENSArgs<'contracts'>,
+  data: string,
+  address: string,
+) => {
+  if (data === null) return
+  const universalResolver = await contracts?.getUniversalResolver()!
+  try {
+    const result = universalResolver.interface.decodeFunctionResult(
+      'reverse',
+      data,
+    )
+    return {
+      name: result['0'],
+      match: result['1'].toLowerCase() === address.toLowerCase(),
+      reverseResolverAddress: result['2'],
+      resolverAddress: result['3'],
+    }
+  } catch {
+    return { name: null, match: false }
+  }
+}
+
+export default {
+  raw,
+  decode,
+}