@ensdomains/ensjs 4.1.2 → 5.0.0-alpha.0

package/src/functions/public/universalWrapper.ts

@@ -1,122 +0,0 @@
-import {
-  type Address,
-  type BaseError,
-  type Hex,
-  decodeFunctionResult,
-  encodeFunctionData,
-  labelhash,
-  toBytes,
-  toHex,
-} from 'viem'
-import type { ClientWithEns } from '../../contracts/consts.js'
-import { getChainContractAddress } from '../../contracts/getChainContractAddress.js'
-import {
-  universalResolverResolveSnippet,
-  universalResolverResolveWithGatewaysSnippet,
-} from '../../contracts/universalResolver.js'
-import type {
-  GenericPassthrough,
-  TransactionRequestWithPassthrough,
-} from '../../types.js'
-import { checkSafeUniversalResolverData } from '../../utils/checkSafeUniversalResolverData.js'
-import { generateFunction } from '../../utils/generateFunction.js'
-import { packetToBytes } from '../../utils/hexEncodedName.js'
-import { encodeLabelhash } from '../../utils/labels.js'
-
-export type UniversalWrapperParameters = {
-  name: string
-  data: Hex
-  strict?: boolean
-  gatewayUrls?: string[]
-}
-
-export type UniversalWrapperReturnType = {
-  data: Hex
-  resolver: Address
-} | null
-
-const encode = (
-  client: ClientWithEns,
-  { name, data, gatewayUrls }: Omit<UniversalWrapperParameters, 'strict'>,
-): TransactionRequestWithPassthrough => {
-  const nameWithSizedLabels = name
-    .split('.')
-    .map((label) => {
-      const labelLength = toBytes(label).byteLength
-      if (labelLength > 255) {
-        return encodeLabelhash(labelhash(label))
-      }
-      return label
-    })
-    .join('.')
-  const to = getChainContractAddress({
-    client,
-    contract: 'ensUniversalResolver',
-  })
-  const args = [toHex(packetToBytes(nameWithSizedLabels)), data] as const
-
-  return {
-    to,
-    ...(gatewayUrls?.length
-      ? {
-          data: encodeFunctionData({
-            abi: universalResolverResolveWithGatewaysSnippet,
-            functionName: 'resolveWithGateways',
-            args: [...args, gatewayUrls] as const,
-          }),
-          passthrough: {
-            args: [...args, gatewayUrls],
-            address: to,
-          },
-        }
-      : {
-          data: encodeFunctionData({
-            abi: universalResolverResolveSnippet,
-            functionName: 'resolve',
-            args,
-          }),
-          passthrough: {
-            args,
-            address: to,
-          },
-        }),
-  }
-}
-
-const decode = async (
-  _client: ClientWithEns,
-  data: Hex | BaseError,
-  passthrough: GenericPassthrough,
-  {
-    strict,
-    gatewayUrls,
-  }: Pick<UniversalWrapperParameters, 'strict' | 'gatewayUrls'>,
-): Promise<UniversalWrapperReturnType> => {
-  const isSafe = checkSafeUniversalResolverData(data, {
-    strict,
-    abi: gatewayUrls
-      ? universalResolverResolveWithGatewaysSnippet
-      : universalResolverResolveSnippet,
-    args: passthrough.args,
-    functionName: 'resolve',
-    address: passthrough.address,
-  })
-
-  if (!isSafe) return null
-
-  try {
-    const result = decodeFunctionResult({
-      abi: universalResolverResolveSnippet,
-      functionName: 'resolve',
-      data,
-    })
-    return { data: result[0], resolver: result[1] }
-  } catch (error) {
-    if (strict) throw error
-    return null
-  }
-}
-
-const universalWrapper = generateFunction({ encode, decode })
-
-export default universalWrapper

package/src/functions/subgraph/client.ts

@@ -1,103 +0,0 @@
-import type { Kind, SelectionNode, SelectionSetNode } from 'graphql'
-import type { RequestMiddleware, ResponseMiddleware } from 'graphql-request'
-import { GraphQLClient } from 'graphql-request'
-import { parse, print, visit } from 'graphql/language/index.js'
-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, {
-    SelectionSet: {
-      enter,
-    },
-  })
-
-  return {
-    ...request,
-    body: JSON.stringify({ ...requestBody, query: print(updatedQuery) }),
-  }
-}
-
-export const responseMiddleware: ResponseMiddleware = (response) => {
-  const traverse = (obj: Record<string, any>) => {
-    if (obj && typeof obj === 'object') {
-      for (const key in obj) {
-        if (Object.prototype.hasOwnProperty.call(obj, key)) {
-          const value = obj[key]
-
-          if (value && typeof value === 'object') {
-            traverse(value)
-          }
-
-          if (
-            value instanceof Object &&
-            'name' in value &&
-            value.name &&
-            typeof value.name === 'string'
-          ) {
-            // Name already in hashed form
-            if (value.name.includes('[')) {
-              // eslint-disable-next-line no-continue
-              continue
-            }
-
-            let hashedName = '[Invalid ENS Name]'
-            try {
-              hashedName = namehash(value.name)
-            } catch (_e) {
-              obj[key] = { ...value, name: hashedName, invalidName: true }
-            }
-
-            if ('id' in value && value.id !== hashedName) {
-              obj[key] = { ...value, name: hashedName, invalidName: true }
-            }
-          }
-        }
-      }
-    }
-  }
-
-  traverse(response)
-}
-
-export const createSubgraphClient = ({ client }: { client: ClientWithEns }) =>
-  new GraphQLClient(client.chain.subgraphs.ens.url, {
-    requestMiddleware,
-    responseMiddleware,
-  })