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

package/src/functions/subgraph/client.ts

@@ -0,0 +1,90 @@
+import type { Kind, SelectionNode, SelectionSetNode } from 'graphql'
+import { GraphQLClient } from 'graphql-request'
+import type { RequestMiddleware, Response } from 'graphql-request/dist/types.js'
+import { parse, print, visit } from 'graphql/language/index.js'
+import traverse from 'traverse'
+import type { ClientWithEns } from '../../contracts/consts.js'
+import { namehash } from '../../utils/normalise.js'
+
+const generateSelection = (selection: string): SelectionNode => ({
+  kind: 'Field' as Kind.FIELD,
+  name: {
+    kind: 'Name' as Kind.NAME,
+    value: selection,
+  },
+  arguments: [],
+  directives: [],
+  alias: undefined,
+  selectionSet: undefined,
+})
+
+const enter = (node: SelectionSetNode) => {
+  let hasName = false
+  let hasId = false
+
+  for (const selection of node.selections) {
+    if ('name' in selection) {
+      if (selection.name.value === 'name') hasName = true
+      else if (selection.name.value === 'id') hasId = true
+    }
+  }
+
+  if (hasName && !hasId) {
+    // eslint-disable-next-line no-param-reassign
+    node.selections = [...node.selections, generateSelection('id')]
+    return node
+  }
+
+  return undefined
+}
+
+export const requestMiddleware: RequestMiddleware = (request) => {
+  if (!request.body) return request
+  const requestBody = JSON.parse(request.body as string)
+  const rawQuery = requestBody.query as string
+  const parsedQuery = parse(rawQuery)
+  const updatedQuery = visit(parsedQuery, {
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    SelectionSet: {
+      enter,
+    },
+  })
+
+  return {
+    ...request,
+    body: JSON.stringify({ ...requestBody, query: print(updatedQuery) }),
+  }
+}
+
+export const responseMiddleware = (response: Response<unknown> | Error) => {
+  traverse(response).forEach(function (responseItem: unknown) {
+    if (
+      responseItem instanceof Object &&
+      'name' in responseItem &&
+      responseItem.name &&
+      typeof responseItem.name === 'string'
+    ) {
+      // Name already in hashed form
+      if (responseItem.name && responseItem.name.includes('[')) {
+        return
+      }
+
+      let hashedName = '[Invalid ENS Name]'
+      try {
+        hashedName = namehash(responseItem.name)
+      } catch (e) {
+        this.update({ ...responseItem, name: hashedName, invalidName: true })
+        return
+      }
+      if ('id' in responseItem && responseItem.id !== hashedName) {
+        this.update({ ...responseItem, name: hashedName, invalidName: true })
+      }
+    }
+  })
+}
+
+export const createSubgraphClient = ({ client }: { client: ClientWithEns }) =>
+  new GraphQLClient(client.chain.subgraphs.ens.url, {
+    requestMiddleware,
+    responseMiddleware,
+  })

package/src/functions/subgraph/events.ts

@@ -0,0 +1,211 @@
+import type { Address, Hex } from 'viem'
+
+export type DomainEventKey =
+  | 'NewOwner'
+  | 'NewResolver'
+  | 'Transfer'
+  | 'NewTTL'
+  | 'WrappedTransfer'
+  | 'NameWrapped'
+  | 'NameUnwrapped'
+  | 'FusesSet'
+  | 'ExpiryExtended'
+export type RegistrationEventKey =
+  | 'NameRegistered'
+  | 'NameRenewed'
+  | 'NameTransferred'
+export type ResolverEventKey =
+  | 'AddrChanged'
+  | 'MulticoinAddrChanged'
+  | 'NameChanged'
+  | 'AbiChanged'
+  | 'PubkeyChanged'
+  | 'TextChanged'
+  | 'ContenthashChanged'
+  | 'InterfaceChanged'
+  | 'AuthorisationChanged'
+  | 'VersionChanged'
+
+type Scalars = {
+  ID: string
+  String: string
+  Boolean: boolean
+  Int: number
+  Float: number
+  Bytes: Hex
+  BigInt: string
+}
+
+type Account = {
+  id: Address
+}
+
+type Resolver = {
+  id: Hex
+}
+
+export type BaseDomainEvent = {
+  type: DomainEventKey
+  id: Scalars['ID']
+  blockNumber: Scalars['Int']
+  transactionID: Scalars['Bytes']
+}
+
+export type Transfer = BaseDomainEvent & {
+  type: 'Transfer'
+  owner: Account
+}
+
+export type NewOwner = BaseDomainEvent & {
+  type: 'NewOwner'
+  owner: Account
+}
+
+export type NewResolver = BaseDomainEvent & {
+  type: 'NewResolver'
+  resolver: Resolver
+}
+
+export type NewTtl = BaseDomainEvent & {
+  type: 'NewTTL'
+  ttl: Scalars['BigInt']
+}
+
+export type WrappedTransfer = BaseDomainEvent & {
+  type: 'WrappedTransfer'
+  owner: Account
+}
+
+export type NameWrapped = BaseDomainEvent & {
+  type: 'NameWrapped'
+  name: Scalars['String']
+  fuses: Scalars['Int']
+  owner: Account
+  expiryDate: Scalars['BigInt']
+}
+
+export type NameUnwrapped = BaseDomainEvent & {
+  type: 'NameUnwrapped'
+  owner: Account
+}
+
+export type FusesSet = BaseDomainEvent & {
+  type: 'FusesSet'
+  fuses: Scalars['Int']
+}
+
+export type ExpiryExtended = BaseDomainEvent & {
+  type: 'ExpiryExtended'
+  expiryDate: Scalars['BigInt']
+}
+
+export type DomainEvent =
+  | Transfer
+  | NewOwner
+  | NewResolver
+  | NewTtl
+  | WrappedTransfer
+  | NameWrapped
+  | NameUnwrapped
+  | FusesSet
+  | ExpiryExtended
+
+export type BaseRegistrationEvent = {
+  type: RegistrationEventKey
+  id: Scalars['ID']
+  blockNumber: Scalars['Int']
+  transactionID: Scalars['Bytes']
+}
+
+export type NameRegistered = BaseRegistrationEvent & {
+  type: 'NameRegistered'
+  registrant: Account
+  expiryDate: Scalars['BigInt']
+}
+
+export type NameRenewed = BaseRegistrationEvent & {
+  type: 'NameRenewed'
+  expiryDate: Scalars['BigInt']
+}
+
+export type NameTransferred = BaseRegistrationEvent & {
+  type: 'NameTransferred'
+  newOwner: Account
+}
+
+export type RegistrationEvent = NameRegistered | NameRenewed | NameTransferred
+
+export type BaseResolverEvent = {
+  type: ResolverEventKey
+  id: Scalars['ID']
+  blockNumber: Scalars['Int']
+  transactionID: Scalars['Bytes']
+}
+
+export type AddrChanged = BaseResolverEvent & {
+  type: 'AddrChanged'
+  addr: Account
+}
+
+export type MulticoinAddrChanged = BaseResolverEvent & {
+  type: 'MulticoinAddrChanged'
+  coinType: Scalars['BigInt']
+  multiaddr: Scalars['Bytes']
+}
+
+export type NameChanged = BaseResolverEvent & {
+  type: 'NameChanged'
+  name: Scalars['String']
+}
+
+export type AbiChanged = BaseResolverEvent & {
+  type: 'AbiChanged'
+  contentType: Scalars['BigInt']
+}
+
+export type PubkeyChanged = BaseResolverEvent & {
+  type: 'PubkeyChanged'
+  x: Scalars['Bytes']
+  y: Scalars['Bytes']
+}
+
+export type TextChanged = BaseResolverEvent & {
+  type: 'TextChanged'
+  key: Scalars['String']
+  value?: Scalars['String'] | null
+}
+
+export type ContenthashChanged = BaseResolverEvent & {
+  type: 'ContenthashChanged'
+  hash: Scalars['Bytes']
+}
+
+export type InterfaceChanged = BaseResolverEvent & {
+  type: 'InterfaceChanged'
+  interfaceID: Scalars['Bytes']
+  implementer: Scalars['Bytes']
+}
+
+export type AuthorisationChanged = BaseResolverEvent & {
+  type: 'AuthorisationChanged'
+  owner: Scalars['Bytes']
+  target: Scalars['Bytes']
+  isAuthorized: Scalars['Boolean']
+}
+
+export type VersionChanged = BaseResolverEvent & {
+  type: 'VersionChanged'
+  version: Scalars['BigInt']
+}
+
+export type ResolverEvent =
+  | AddrChanged
+  | MulticoinAddrChanged
+  | NameChanged
+  | AbiChanged
+  | PubkeyChanged
+  | TextChanged
+  | ContenthashChanged
+  | InterfaceChanged
+  | AuthorisationChanged
+  | VersionChanged

package/src/functions/subgraph/fragments.ts

@@ -0,0 +1,88 @@
+import { gql } from 'graphql-request'
+import type { Address, Hex } from 'viem'
+
+export const domainDetailsWithoutParentFragment = gql`
+  fragment DomainDetailsWithoutParent on Domain {
+    id
+    labelName
+    labelhash
+    name
+    isMigrated
+    createdAt
+    resolvedAddress {
+      id
+    }
+    owner {
+      id
+    }
+    registrant {
+      id
+    }
+    wrappedOwner {
+      id
+    }
+  }
+`
+
+export const domainDetailsFragment = gql`
+  fragment DomainDetails on Domain {
+    ...DomainDetailsWithoutParent
+    parent {
+      name
+    }
+  }
+  ${domainDetailsWithoutParentFragment}
+`
+
+export type SubgraphDomainFragment = {
+  id: Hex
+  labelName: string | null
+  labelhash: Hex
+  name: string
+  isMigrated: boolean
+  parent?: {
+    name: string
+  }
+  createdAt: string
+  resolvedAddress?: {
+    id: Address
+  }
+  owner: {
+    id: Address
+  }
+  registrant?: {
+    id: Address
+  }
+  wrappedOwner?: {
+    id: Address
+  }
+}
+
+export const registrationDetailsFragment = gql`
+  fragment RegistrationDetails on Registration {
+    registrationDate
+    expiryDate
+  }
+`
+
+export type SubgraphRegistrationFragment = {
+  registrationDate: string
+  expiryDate: string
+}
+
+export const wrappedDomainDetailsFragment = gql`
+  fragment WrappedDomainDetails on WrappedDomain {
+    expiryDate
+    fuses
+  }
+`
+
+export type SubgraphWrappedDomainFragment = {
+  expiryDate: string
+  fuses: string
+}
+
+export type SubgraphDomain = SubgraphDomainFragment & {
+  registration?: SubgraphRegistrationFragment
+  wrappedDomain?: SubgraphWrappedDomainFragment
+}

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

@@ -0,0 +1,31 @@
+import { publicClient } from '../../tests/addTestContracts.js'
+import getDecodedName from './getDecodedName.js'
+
+it('should decode a name via namehash lookup', async () => {
+  const result = await getDecodedName(publicClient, {
+    name: '[9c22ff5f21f0b81b113e63f7db6da94fedef11b2119b4088b89664fb9a3cb658].wrapped-with-subnames.eth',
+  })
+  expect(result).toBe('test.wrapped-with-subnames.eth')
+})
+it('should decode a name via labelhash lookup', async () => {
+  const result = await getDecodedName(publicClient, {
+    name: '[f81b517a242b218999ec8eec0ea6e2ddbef2a367a14e93f4a32a39e260f686ad].eth',
+  })
+  expect(result).toBe('test123.eth')
+})
+it('should partially decode a name when allowIncomplete is true', async () => {
+  const result = await getDecodedName(publicClient, {
+    name: '[7bffb6e3ebf801bbc438fea5c11d957ba49978bdc8d52b71cba974139d22edea].[6c14e1739568670447af1d5af8a571008f7a582068af18bcd7ac2dbc13bb37c1].eth',
+    allowIncomplete: true,
+  })
+  expect(result).toBe(
+    '[7bffb6e3ebf801bbc438fea5c11d957ba49978bdc8d52b71cba974139d22edea].with-unknown-subnames.eth',
+  )
+})
+it('should not partially decode a name when allowIncomplete is false', async () => {
+  const result = await getDecodedName(publicClient, {
+    name: '[7bffb6e3ebf801bbc438fea5c11d957ba49978bdc8d52b71cba974139d22edea].[6c14e1739568670447af1d5af8a571008f7a582068af18bcd7ac2dbc13bb37c1].eth',
+    allowIncomplete: false,
+  })
+  expect(result).toBeNull()
+})

package/src/functions/subgraph/getDecodedName.ts

@@ -0,0 +1,120 @@
+import { gql } from 'graphql-request'
+import type { ClientWithEns } from '../../contracts/consts.js'
+import {
+  checkIsDecrypted,
+  decodeLabelhash,
+  isEncodedLabelhash,
+} from '../../utils/labels.js'
+import { namehash } from '../../utils/normalise.js'
+import { createSubgraphClient } from './client.js'
+
+export type GetDecodedNameParameters = {
+  /** Name with unknown labels */
+  name: string
+  /** Allow a name with unknown labels to be returned */
+  allowIncomplete?: boolean
+}
+
+export type GetDecodedNameReturnType = string | null
+
+type SubgraphResult = {
+  namehashLookup?: { name: string }
+} & {
+  [key: `labels${number}`]: [{ labelName: string }] | []
+}
+
+/**
+ * Gets the full name for a name with unknown labels from the subgraph.
+ * @param client - {@link ClientWithEns}
+ * @param parameters - {@link GetDecodedNameParameters}
+ * @returns Full name, or null if name was could not be filled. {@link GetDecodedNameReturnType}
+ *
+ * @example
+ * import { createPublicClient, http } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { addEnsContracts, getDecodedName } from '@ensdomains/ensjs'
+ *
+ * const client = createPublicClient({
+ *   chain: addEnsContracts(mainnet),
+ *   transport: http(),
+ * })
+ * const result = await getDecodedName(client, { name: '[5cee339e13375638553bdf5a6e36ba80fb9f6a4f0783680884d92b558aa471da].eth' })
+ * // ens.eth
+ */
+const getDecodedName = async (
+  client: ClientWithEns,
+  { name, allowIncomplete }: GetDecodedNameParameters,
+): Promise<GetDecodedNameReturnType> => {
+  if (checkIsDecrypted(name)) return name
+  // try to fetch the name from an existing Domain entity
+  // also try to fetch the label names from any Domain entities that have a corresponding labelhash
+  const labels = name.split('.')
+
+  const subgraphClient = createSubgraphClient({ client })
+
+  let labelsQuery = ''
+  for (let i = 0; i < labels.length; i += 1) {
+    const label = labels[i]
+    if (isEncodedLabelhash(label)) {
+      labelsQuery += gql`
+        labels${i}: domains(first: 1, where: { labelhash: "${decodeLabelhash(
+        label,
+      ).toLowerCase()}", labelName_not: null }) {
+          labelName
+        }
+      `
+    }
+  }
+
+  const decodedNameQuery = gql`
+    query decodedName($id: String!) {
+      namehashLookup: domain(id: $id) {
+        name
+      }
+      ${labelsQuery}
+    }
+  `
+
+  const decodedNameResult = await subgraphClient.request<SubgraphResult>(
+    decodedNameQuery,
+    {
+      id: namehash(name),
+    },
+  )
+  if (!decodedNameResult) return null
+
+  const attemptedDecodedLabels = [...labels]
+
+  const {
+    namehashLookup: { name: namehashLookupResult } = { name: undefined },
+    ...labelResults
+  } = decodedNameResult
+  if (namehashLookupResult) {
+    const namehashLookupLabels = namehashLookupResult.split('.')
+    for (let i = 0; i < namehashLookupLabels.length; i += 1) {
+      const label = namehashLookupLabels[i]
+      if (!isEncodedLabelhash(label)) {
+        attemptedDecodedLabels[i] = label
+      }
+    }
+    const joinedResult = attemptedDecodedLabels.join('.')
+    if (checkIsDecrypted(joinedResult)) return joinedResult
+  }
+
+  if (Object.keys(labelResults).length !== 0) {
+    for (const [key, value] of Object.entries(labelResults)) {
+      if (value.length && value[0].labelName) {
+        attemptedDecodedLabels[parseInt(key.replace('labels', ''))] =
+          value[0].labelName
+      }
+    }
+  }
+
+  const joinedResult = attemptedDecodedLabels.join('.')
+  if (checkIsDecrypted(joinedResult) || allowIncomplete) return joinedResult
+
+  // name is not decrypted
+  return null
+}
+
+export default getDecodedName

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

@@ -0,0 +1,39 @@
+import { publicClient } from '../../tests/addTestContracts.js'
+import getNameHistory from './getNameHistory.js'
+
+it('returns null for a non-existent name', async () => {
+  const result = await getNameHistory(publicClient, {
+    name: 'test123123cool.eth',
+  })
+  expect(result).toBeNull()
+})
+
+it('returns the history of a name', async () => {
+  const result = await getNameHistory(publicClient, {
+    name: 'with-profile.eth',
+  })
+  if (!result) throw new Error('No result')
+  expect(result.domainEvents.length).toBeGreaterThan(0)
+  expect(result.registrationEvents!.length).toBeGreaterThan(0)
+  expect(result.resolverEvents!.length).toBeGreaterThan(0)
+})
+
+it('returns the history of a wrapped name', async () => {
+  const result = await getNameHistory(publicClient, {
+    name: 'wrapped.eth',
+  })
+  if (!result) throw new Error('No result')
+  expect(result.domainEvents.length).toBeGreaterThan(0)
+  expect(result.registrationEvents!.length).toBeGreaterThan(0)
+  expect(result.resolverEvents).not.toBeNull()
+})
+
+it('returns the history of a subname', async () => {
+  const result = await getNameHistory(publicClient, {
+    name: 'test.wrapped-with-subnames.eth',
+  })
+  if (!result) throw new Error('No result')
+  expect(result.domainEvents.length).toBeGreaterThan(0)
+  expect(result.registrationEvents).toBeNull()
+  expect(result.resolverEvents).not.toBeNull()
+})