@ensdomains/ensjs 2.1.0 → 3.0.0-alpha.3

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(
+      '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+    )
+    expect(result).toBeTruthy()
+    if (result) {
+      expect(result.name).toBe('jefflau.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('jefflau.eth')
+    await tx?.wait()
+
+    const result = await ENSInstance.getName(accounts[0])
+    expect(result).toBeTruthy()
+    if (result) {
+      expect(result.name).toBe('jefflau.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,
+}

package/src/functions/getNames.test.ts

@@ -0,0 +1,247 @@
+import { ENS } from '..'
+import { OwnedName, Registration } from '../functions/getNames'
+import setup from '../tests/setup'
+
+let ENSInstance: ENS
+
+beforeAll(async () => {
+  ;({ ENSInstance } = await setup())
+})
+
+const testProperties = (obj: object, ...properties: string[]) =>
+  properties.map((property) => expect(obj).toHaveProperty(property))
+
+const testNotProperties = (obj: object, ...properties: string[]) =>
+  properties.map((property) => expect(obj).not.toHaveProperty(property))
+
+describe('getNames', () => {
+  let totalRegistrations: number = 0
+  let totalOwnedNames: number = 0
+  it('should get the registrations for an address', async () => {
+    const result = await ENSInstance.getNames({
+      address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+      type: 'registrant',
+    })
+    totalRegistrations = result.length
+    expect(result).toBeTruthy()
+    testProperties(
+      result[0],
+      'expiryDate',
+      'registrationDate',
+      'id',
+      'labelName',
+      'labelhash',
+      'name',
+      'isMigrated',
+      'parent',
+      'truncatedName',
+    )
+  })
+  it('should get the owned names for an address', async () => {
+    const result = await ENSInstance.getNames({
+      address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+      type: 'owner',
+    })
+    totalOwnedNames = result.length
+    expect(result).toBeTruthy()
+    testProperties(
+      result[0],
+      'id',
+      'labelName',
+      'labelhash',
+      'name',
+      'isMigrated',
+      'parent',
+      'truncatedName',
+    )
+    testNotProperties(result[0], 'expiryDate', 'registrationDate')
+  })
+  it('should get the registrations for an address with pagination', async () => {
+    const pageOne = await ENSInstance.getNames({
+      address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+      type: 'registrant',
+      page: 0,
+    })
+    expect(pageOne).toHaveLength(10)
+    const pageTwo = await ENSInstance.getNames({
+      address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+      type: 'registrant',
+      page: 1,
+    })
+    expect(pageTwo).toHaveLength(totalRegistrations % 10)
+  })
+  it('should get the owned names for an address with pagination', async () => {
+    const pageOne = await ENSInstance.getNames({
+      address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+      type: 'owner',
+      page: 0,
+    })
+    expect(pageOne).toHaveLength(10)
+    const pageTwo = await ENSInstance.getNames({
+      address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+      type: 'owner',
+      page: 1,
+    })
+    expect(pageTwo).toHaveLength(10)
+    const pageThree = await ENSInstance.getNames({
+      address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+      type: 'owner',
+      page: 2,
+    })
+    expect(pageThree).toHaveLength(10)
+    const pageFour = await ENSInstance.getNames({
+      address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+      type: 'owner',
+      page: 3,
+    })
+    expect(pageFour).toHaveLength(totalOwnedNames % 10)
+  })
+  describe('orderBy', () => {
+    describe('registrations', () => {
+      it('descending registrationDate', async () => {
+        const registrationDateOrderedDesc = (await ENSInstance.getNames({
+          address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+          type: 'registrant',
+          orderBy: 'registrationDate',
+          orderDirection: 'desc',
+        })) as Registration[]
+        registrationDateOrderedDesc.reduce((prev, curr) => {
+          expect(prev.registrationDate.getTime()).toBeGreaterThanOrEqual(
+            curr.registrationDate.getTime(),
+          )
+          return curr
+        })
+      })
+      it('ascending registrationDate', async () => {
+        const registrationDateOrderedAsc = (await ENSInstance.getNames({
+          address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+          type: 'registrant',
+          orderBy: 'registrationDate',
+          orderDirection: 'asc',
+        })) as Registration[]
+        registrationDateOrderedAsc.reduce((prev, curr) => {
+          expect(prev.registrationDate.getTime()).toBeLessThanOrEqual(
+            curr.registrationDate.getTime(),
+          )
+          return curr
+        })
+      })
+      it('descending expiryDate', async () => {
+        const expiryDateOrderedDesc = (await ENSInstance.getNames({
+          address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+          type: 'registrant',
+          orderBy: 'expiryDate',
+          orderDirection: 'desc',
+        })) as Registration[]
+        expiryDateOrderedDesc.reduce((prev, curr) => {
+          expect(prev.expiryDate.getTime()).toBeGreaterThanOrEqual(
+            curr.expiryDate.getTime(),
+          )
+          return curr
+        })
+      })
+      it('ascending expiryDate', async () => {
+        const expiryDateOrderedAsc = (await ENSInstance.getNames({
+          address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+          type: 'registrant',
+          orderBy: 'expiryDate',
+          orderDirection: 'asc',
+        })) as Registration[]
+        expiryDateOrderedAsc.reduce((prev, curr) => {
+          expect(prev.expiryDate.getTime()).toBeLessThanOrEqual(
+            curr.expiryDate.getTime(),
+          )
+          return curr
+        })
+      })
+      it('descending labelName', async () => {
+        const labelNameOrderedDesc = (await ENSInstance.getNames({
+          address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+          type: 'registrant',
+          orderBy: 'labelName',
+          orderDirection: 'desc',
+        })) as Registration[]
+        labelNameOrderedDesc.reduce((prev, curr) => {
+          expect((prev.labelName || '') > (curr.labelName || '')).toBeTruthy()
+          return curr
+        })
+      })
+      it('ascending labelName', async () => {
+        const labelNameOrderedAsc = (await ENSInstance.getNames({
+          address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+          type: 'registrant',
+          orderBy: 'labelName',
+          orderDirection: 'asc',
+        })) as Registration[]
+        labelNameOrderedAsc.reduce((prev, curr) => {
+          expect((prev.labelName || '') < (curr.labelName || '')).toBeTruthy()
+          return curr
+        })
+      })
+    })
+    describe('owned names', () => {
+      it('descending createdAt', async () => {
+        const createdAtOrderedDesc = (await ENSInstance.getNames({
+          address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+          type: 'owner',
+          orderBy: 'createdAt',
+          orderDirection: 'desc',
+        })) as OwnedName[]
+        createdAtOrderedDesc.reduce((prev, curr) => {
+          expect(prev.createdAt.getTime()).toBeGreaterThanOrEqual(
+            curr.createdAt.getTime(),
+          )
+          return curr
+        })
+      })
+      it('ascending createdAt', async () => {
+        const createdAtOrderedAsc = (await ENSInstance.getNames({
+          address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+          type: 'owner',
+          orderBy: 'createdAt',
+          orderDirection: 'asc',
+        })) as OwnedName[]
+        createdAtOrderedAsc.reduce((prev, curr) => {
+          expect(prev.createdAt.getTime()).toBeLessThanOrEqual(
+            curr.createdAt.getTime(),
+          )
+          return curr
+        })
+      })
+      it('descending labelName', async () => {
+        const labelNameOrderedDesc = (await ENSInstance.getNames({
+          address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+          type: 'owner',
+          orderBy: 'labelName',
+          orderDirection: 'desc',
+        })) as Registration[]
+        labelNameOrderedDesc.reduce((prev, curr) => {
+          if (
+            (!prev.labelName && !curr.labelName) ||
+            (!prev.labelName && curr.labelName)
+          )
+            return curr
+          expect((prev.labelName || '') > (curr.labelName || '')).toBeTruthy()
+          return curr
+        })
+      })
+      it('ascending labelName', async () => {
+        const labelNameOrderedAsc = (await ENSInstance.getNames({
+          address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+          type: 'owner',
+          orderBy: 'labelName',
+          orderDirection: 'asc',
+        })) as Registration[]
+        labelNameOrderedAsc.reduce((prev, curr) => {
+          if (
+            (!prev.labelName && !curr.labelName) ||
+            (prev.labelName && !curr.labelName)
+          )
+            return curr
+          expect((prev.labelName || '') < (curr.labelName || '')).toBeTruthy()
+          return curr
+        })
+      })
+    })
+  })
+})