@ensdomains/ensjs 3.0.0-alpha.8 → 3.0.0-beta.1

package/src/functions/subgraph/getNameHistory.ts

@@ -0,0 +1,326 @@
+import { formatsByCoinType } from '@ensdomains/address-encoder'
+import { gql } from 'graphql-request'
+import type { ClientWithEns } from '../../contracts/consts.js'
+import { decodeContenthash } from '../../utils/contentHash.js'
+import { namehash } from '../../utils/normalise.js'
+import { createSubgraphClient } from './client.js'
+import type {
+  BaseResolverEvent,
+  ContenthashChanged,
+  DomainEvent,
+  MulticoinAddrChanged,
+  RegistrationEvent,
+  ResolverEvent,
+} from './events.js'
+
+export type GetNameHistoryParameters = {
+  /** Name to get history for */
+  name: string
+}
+
+type SubgraphResult = {
+  domain?: {
+    events: DomainEvent[]
+    registration?: {
+      events: RegistrationEvent[]
+    }
+    resolver?: {
+      events: ResolverEvent[]
+    }
+  }
+}
+
+type FlattenedEvent<TEvent extends {}> = {
+  [K in keyof TEvent]: TEvent[K] extends { id: string } ? string : TEvent[K]
+}
+
+type ReturnDomainEvent = FlattenedEvent<DomainEvent>
+type ReturnRegistrationEvent = FlattenedEvent<RegistrationEvent>
+type ReturnResolverEvent = FlattenedEvent<
+  | Exclude<ResolverEvent, MulticoinAddrChanged | ContenthashChanged>
+  | (BaseResolverEvent & {
+      type: 'MulticoinAddrChanged'
+      coinType: string
+      coinName: string | null
+      decoded: boolean
+      addr: string | null
+    })
+  | (BaseResolverEvent & {
+      type: 'ContenthashChanged'
+      decoded: boolean
+      contentHash: string | null
+      protocolType: string | null
+    })
+>
+
+export type GetNameHistoryReturnType = {
+  /** Array of domain events */
+  domainEvents: ReturnDomainEvent[]
+  /** Array of registration events */
+  registrationEvents: ReturnRegistrationEvent[] | null
+  /** Array of resolver events */
+  resolverEvents: ReturnResolverEvent[] | null
+} | null
+
+/**
+ * Gets the history of a name from the subgraph.
+ * @param client - {@link ClientWithEns}
+ * @param parameters - {@link GetNameHistoryParameters}
+ * @returns History object, or null if name could not be found. {@link GetNameHistoryReturnType}
+ *
+ * @example
+ * import { createPublicClient, http } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { addEnsContracts, getNameHistory } from '@ensdomains/ensjs'
+ *
+ * const client = createPublicClient({
+ *   chain: addEnsContracts(mainnet),
+ *   transport: http(),
+ * })
+ * const result = await getNameHistory(client, { name: 'ens.eth' })
+ */
+const getNameHistory = async (
+  client: ClientWithEns,
+  { name }: GetNameHistoryParameters,
+): Promise<GetNameHistoryReturnType> => {
+  const subgraphClient = createSubgraphClient({ client })
+
+  const query = gql`
+    query getNameHistory($id: String!) {
+      domain(id: $id) {
+        events {
+          id
+          blockNumber
+          transactionID
+          type: __typename
+          ... on Transfer {
+            owner {
+              id
+            }
+          }
+          ... on NewOwner {
+            owner {
+              id
+            }
+          }
+          ... on NewResolver {
+            resolver {
+              id
+            }
+          }
+          ... on NewTTL {
+            ttl
+          }
+          ... on WrappedTransfer {
+            owner {
+              id
+            }
+          }
+          ... on NameWrapped {
+            fuses
+            expiryDate
+            owner {
+              id
+            }
+          }
+          ... on NameUnwrapped {
+            owner {
+              id
+            }
+          }
+          ... on FusesSet {
+            fuses
+          }
+          ... on ExpiryExtended {
+            expiryDate
+          }
+        }
+        registration {
+          events {
+            id
+            blockNumber
+            transactionID
+            type: __typename
+            ... on NameRegistered {
+              registrant {
+                id
+              }
+              expiryDate
+            }
+            ... on NameRenewed {
+              expiryDate
+            }
+            ... on NameTransferred {
+              newOwner {
+                id
+              }
+            }
+          }
+        }
+        resolver {
+          events {
+            id
+            blockNumber
+            transactionID
+            type: __typename
+            ... on AddrChanged {
+              addr {
+                id
+              }
+            }
+            ... on MulticoinAddrChanged {
+              coinType
+              multiaddr: addr
+            }
+            ... on NameChanged {
+              name
+            }
+            ... on AbiChanged {
+              contentType
+            }
+            ... on PubkeyChanged {
+              x
+              y
+            }
+            ... on TextChanged {
+              key
+              value
+            }
+            ... on ContenthashChanged {
+              hash
+            }
+            ... on InterfaceChanged {
+              interfaceID
+              implementer
+            }
+            ... on AuthorisationChanged {
+              owner
+              target
+              isAuthorized
+            }
+            ... on VersionChanged {
+              version
+            }
+          }
+        }
+      }
+    }
+  `
+
+  const queryVars = {
+    id: namehash(name),
+  }
+
+  const result = await subgraphClient.request<SubgraphResult, typeof queryVars>(
+    query,
+    queryVars,
+  )
+
+  if (!result.domain) return null
+
+  const domainEvents = result.domain.events.map(
+    (event: DomainEvent): ReturnDomainEvent => {
+      switch (event.type) {
+        case 'NewResolver': {
+          return {
+            ...event,
+            resolver: event.resolver.id.split('-')[0],
+          }
+        }
+        case 'NewOwner':
+        case 'Transfer':
+        case 'WrappedTransfer':
+        case 'NameWrapped':
+        case 'NameUnwrapped': {
+          return {
+            ...event,
+            owner: event.owner.id,
+          }
+        }
+        default:
+          return event
+      }
+    },
+  )
+
+  const registrationEvents = result.domain?.registration?.events.map(
+    (event: RegistrationEvent): ReturnRegistrationEvent => {
+      switch (event.type) {
+        case 'NameRegistered': {
+          return {
+            ...event,
+            registrant: event.registrant.id,
+          }
+        }
+        case 'NameTransferred': {
+          return {
+            ...event,
+            newOwner: event.newOwner.id,
+          }
+        }
+        default:
+          return event
+      }
+    },
+  )
+
+  const resolverEvents = result.domain?.resolver?.events.map(
+    (event: ResolverEvent): ReturnResolverEvent => {
+      switch (event.type) {
+        case 'AddrChanged': {
+          return {
+            ...event,
+            addr: event.addr.id,
+          }
+        }
+        case 'MulticoinAddrChanged': {
+          const { multiaddr, ...event_ } = event
+          const format = formatsByCoinType[parseInt(event.coinType)]
+          if (!format) {
+            return {
+              ...event_,
+              coinName: null,
+              decoded: false,
+              addr: multiaddr,
+            }
+          }
+          if (BigInt(multiaddr) === 0n) {
+            return {
+              ...event_,
+              coinName: format.name,
+              decoded: true,
+              addr: null,
+            }
+          }
+          return {
+            ...event_,
+            coinName: format.name,
+            decoded: true,
+            addr: format.encoder(Buffer.from(multiaddr.slice(2), 'hex')),
+          }
+        }
+        case 'ContenthashChanged': {
+          const { decoded: contentHash, protocolType } = decodeContenthash(
+            event.hash,
+          ) || { protocolType: null, decoded: null }
+          return {
+            ...event,
+            decoded: contentHash !== null,
+            contentHash,
+            protocolType,
+          }
+        }
+        default:
+          return event
+      }
+    },
+  )
+
+  return {
+    domainEvents,
+    registrationEvents: registrationEvents || null,
+    resolverEvents: resolverEvents || null,
+  }
+}
+
+export default getNameHistory

package/src/functions/subgraph/getNamesForAddress.test.ts

@@ -0,0 +1,244 @@
+/* eslint-disable no-await-in-loop */
+
+import type { Address } from 'viem'
+import { publicClient, walletClient } from '../../tests/addTestContracts.js'
+import getNamesForAddress, {
+  type NameWithRelation,
+} from './getNamesForAddress.js'
+
+let accounts: Address[]
+
+beforeAll(async () => {
+  accounts = await walletClient.getAddresses()
+})
+
+it('returns with default values', async () => {
+  const result = await getNamesForAddress(publicClient, {
+    address: accounts[1],
+  })
+
+  expect(result).toBeTruthy()
+  // arbitrary number, just to make sure we get some results
+  expect(result.length).toBeGreaterThan(10)
+})
+
+it('has registration date on .eth names', async () => {
+  const result = await getNamesForAddress(publicClient, {
+    address: accounts[1],
+  })
+  if (!result.length) throw new Error('No names found')
+  for (const name of result) {
+    if (name.parentName === 'eth') {
+      expect(name.registrationDate).toBeTruthy()
+    }
+  }
+})
+describe('filter', () => {
+  it('filters by owner', async () => {
+    const result = await getNamesForAddress(publicClient, {
+      address: accounts[1],
+      filter: {
+        owner: true,
+        registrant: false,
+        resolvedAddress: false,
+        wrappedOwner: false,
+      },
+    })
+    if (!result.length) throw new Error('No names found')
+    for (const name of result) {
+      expect(name.owner).toBe(accounts[1])
+      expect(name.relation.owner).toBe(true)
+    }
+  })
+  it('filters by registrant', async () => {
+    const result = await getNamesForAddress(publicClient, {
+      address: accounts[1],
+      filter: {
+        owner: false,
+        registrant: true,
+        resolvedAddress: false,
+        wrappedOwner: false,
+      },
+    })
+    if (!result.length) throw new Error('No names found')
+    for (const name of result) {
+      expect(name.registrant).toBe(accounts[1])
+      expect(name.relation.registrant).toBe(true)
+    }
+  })
+  it('filters by resolved address', async () => {
+    const result = await getNamesForAddress(publicClient, {
+      address: accounts[1],
+      filter: {
+        owner: false,
+        registrant: false,
+        resolvedAddress: true,
+        wrappedOwner: false,
+      },
+    })
+    if (!result.length) throw new Error('No names found')
+    for (const name of result) {
+      expect(name.resolvedAddress).toBe(accounts[1])
+      expect(name.relation.resolvedAddress).toBe(true)
+    }
+  })
+  it('filters by wrapped owner', async () => {
+    const result = await getNamesForAddress(publicClient, {
+      address: accounts[1],
+      filter: {
+        owner: false,
+        registrant: false,
+        resolvedAddress: false,
+        wrappedOwner: true,
+      },
+    })
+    if (!result.length) throw new Error('No names found')
+    for (const name of result) {
+      expect(name.wrappedOwner).toBe(accounts[1])
+      expect(name.relation.wrappedOwner).toBe(true)
+    }
+  })
+  it('allows including expired names', async () => {
+    const result = await getNamesForAddress(publicClient, {
+      address: accounts[1],
+      filter: {
+        owner: true,
+        registrant: true,
+        resolvedAddress: true,
+        wrappedOwner: true,
+        allowExpired: true,
+      },
+    })
+    if (!result.length) throw new Error('No names found')
+    const expiredNames = result.filter(
+      (x) => x.expiryDate?.date && x.expiryDate.date < new Date(),
+    )
+    expect(expiredNames.length).toBeGreaterThan(0)
+  })
+  it('allows including reverse record', async () => {
+    const result = await getNamesForAddress(publicClient, {
+      address: accounts[2],
+      filter: {
+        owner: true,
+        registrant: true,
+        resolvedAddress: true,
+        wrappedOwner: true,
+        allowReverseRecord: true,
+      },
+    })
+    if (!result.length) throw new Error('No names found')
+    const reverseRecordNames = result.filter(
+      (x) => x.parentName === 'addr.reverse',
+    )
+    expect(reverseRecordNames.length).toBeGreaterThan(0)
+  })
+})
+
+describe.each([
+  {
+    orderBy: 'name',
+    orderDirection: 'asc',
+    compareFn: (a: NameWithRelation, b: NameWithRelation) =>
+      (a.name || '').localeCompare(b.name || ''),
+  },
+  {
+    orderBy: 'name',
+    orderDirection: 'desc',
+    compareFn: (a: NameWithRelation, b: NameWithRelation) =>
+      (b.name || '').localeCompare(a.name || ''),
+  },
+  {
+    orderBy: 'labelName',
+    orderDirection: 'asc',
+    compareFn: (a: NameWithRelation, b: NameWithRelation) => {
+      const aLabelName = a.labelName || ''
+      const bLabelName = b.labelName || ''
+      return aLabelName.localeCompare(bLabelName)
+    },
+  },
+  {
+    orderBy: 'labelName',
+    orderDirection: 'desc',
+    compareFn: (a: NameWithRelation, b: NameWithRelation) => {
+      const aLabelName = a.labelName || ''
+      const bLabelName = b.labelName || ''
+      return bLabelName.localeCompare(aLabelName)
+    },
+  },
+  {
+    orderBy: 'expiryDate',
+    orderDirection: 'asc',
+    compareFn: (a: NameWithRelation, b: NameWithRelation) => {
+      const aExpiryDate = a.expiryDate?.value || Infinity
+      const bExpiryDate = b.expiryDate?.value || Infinity
+      return aExpiryDate - bExpiryDate
+    },
+  },
+  {
+    orderBy: 'expiryDate',
+    orderDirection: 'desc',
+    compareFn: (a: NameWithRelation, b: NameWithRelation) => {
+      const aExpiryDate = a.expiryDate?.value || Infinity
+      const bExpiryDate = b.expiryDate?.value || Infinity
+      return bExpiryDate - aExpiryDate
+    },
+  },
+  {
+    orderBy: 'createdAt',
+    orderDirection: 'asc',
+    compareFn: (a: NameWithRelation, b: NameWithRelation) => {
+      const aCreatedAt = a.createdAt.value
+      const bCreatedAt = b.createdAt.value
+      return aCreatedAt - bCreatedAt
+    },
+  },
+  {
+    orderBy: 'createdAt',
+    orderDirection: 'desc',
+    compareFn: (a: NameWithRelation, b: NameWithRelation) => {
+      const aCreatedAt = a.createdAt.value
+      const bCreatedAt = b.createdAt.value
+      return bCreatedAt - aCreatedAt
+    },
+  },
+])(
+  'filters by $orderBy $orderDirection',
+  ({ orderBy, orderDirection, compareFn }) => {
+    it('is consistent between full result and paginated results', async () => {
+      const fullResult = await getNamesForAddress(publicClient, {
+        address: accounts[1],
+        orderBy: orderBy as any,
+        orderDirection: orderDirection as any,
+        pageSize: 1000,
+      })
+      if (!fullResult.length) throw new Error('No names found')
+      const paginatedResults = []
+      let lastResult: NameWithRelation[] = []
+      do {
+        const result = await getNamesForAddress(publicClient, {
+          address: accounts[1],
+          orderBy: orderBy as any,
+          orderDirection: orderDirection as any,
+          previousPage: lastResult,
+          pageSize: 5,
+        })
+        paginatedResults.push(...result)
+        lastResult = result
+      } while (lastResult.length)
+
+      expect(paginatedResults.length).toBe(fullResult.length)
+      expect(paginatedResults).toStrictEqual(fullResult)
+    })
+    it('is sorted correctly', async () => {
+      const fullResult = await getNamesForAddress(publicClient, {
+        address: accounts[1],
+        orderBy: orderBy as any,
+        orderDirection: orderDirection as any,
+        pageSize: 1000,
+      })
+      if (!fullResult.length) throw new Error('No names found')
+      const sortedResult = [...fullResult].sort(compareFn)
+      expect(fullResult).toEqual(sortedResult)
+    })
+  },
+)