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

package/src/functions/public/getSupportedInterfaces.ts

@@ -0,0 +1,92 @@
+import {
+  BaseError,
+  encodeFunctionData,
+  padHex,
+  type Address,
+  type Hex,
+} from 'viem'
+import type { ClientWithEns } from '../../contracts/consts.js'
+import { erc165SupportsInterfaceSnippet } from '../../contracts/erc165.js'
+import type {
+  SimpleTransactionRequest,
+  TransactionRequestWithPassthrough,
+} from '../../types.js'
+import { generateFunction } from '../../utils/generateFunction.js'
+import multicallWrapper from './multicallWrapper.js'
+
+export type GetSupportedInterfacesParameters<
+  TInterfaces extends readonly Hex[],
+> = {
+  address: Address
+  interfaces: TInterfaces
+}
+
+export type GetSupportedInterfacesReturnType<
+  TInterfaces extends readonly Hex[],
+> = {
+  -readonly [K in keyof TInterfaces]: boolean
+}
+
+const encodeInterface = (interfaceId: Hex): Hex =>
+  encodeFunctionData({
+    abi: erc165SupportsInterfaceSnippet,
+    functionName: 'supportsInterface',
+    args: [interfaceId],
+  })
+
+const encode = <TInterfaces extends Hex[]>(
+  client: ClientWithEns,
+  { address, interfaces }: GetSupportedInterfacesParameters<TInterfaces>,
+): TransactionRequestWithPassthrough => {
+  const calls = interfaces.map((interfaceId) => ({
+    to: address,
+    data: encodeInterface(interfaceId),
+  }))
+  const encoded = multicallWrapper.encode(client, {
+    transactions: calls,
+  })
+  return {
+    ...encoded,
+    passthrough: calls,
+  }
+}
+
+const decode = async <const TInterfaces extends readonly Hex[]>(
+  client: ClientWithEns,
+  data: Hex | BaseError,
+  passthrough: SimpleTransactionRequest[],
+): Promise<GetSupportedInterfacesReturnType<TInterfaces>> => {
+  if (typeof data === 'object') throw data
+  const result = await multicallWrapper.decode(client, data, passthrough)
+  return result.map(
+    (r) => r.success && r.returnData === padHex('0x01'),
+  ) as GetSupportedInterfacesReturnType<TInterfaces>
+}
+
+type EncoderFunction = typeof encode
+type DecoderFunction = typeof decode
+
+type BatchableFunctionObject = {
+  encode: EncoderFunction
+  decode: DecoderFunction
+  batch: <
+    const TInterfaces extends readonly Hex[],
+    TParams extends GetSupportedInterfacesParameters<TInterfaces>,
+  >(
+    args: TParams,
+  ) => {
+    args: [TParams]
+    encode: EncoderFunction
+    decode: typeof decode<TInterfaces>
+  }
+}
+
+const getSupportedInterfaces = generateFunction({ encode, decode }) as (<
+  const TInterfaces extends readonly Hex[],
+>(
+  client: ClientWithEns,
+  { address, interfaces }: GetSupportedInterfacesParameters<TInterfaces>,
+) => Promise<GetSupportedInterfacesReturnType<TInterfaces>>) &
+  BatchableFunctionObject
+
+export default getSupportedInterfaces

package/src/functions/public/getTextRecord.ts

@@ -0,0 +1,65 @@
+import type { BaseError, Hex } from 'viem'
+import type { ClientWithEns } from '../../contracts/consts.js'
+import type {
+  GenericPassthrough,
+  Prettify,
+  SimpleTransactionRequest,
+} from '../../types.js'
+import {
+  generateFunction,
+  type GeneratedFunction,
+} from '../../utils/generateFunction.js'
+import _getText, {
+  type InternalGetTextParameters,
+  type InternalGetTextReturnType,
+} from './_getText.js'
+import universalWrapper from './universalWrapper.js'
+
+export type GetTextRecordParameters = Prettify<InternalGetTextParameters>
+
+export type GetTextRecordReturnType = Prettify<InternalGetTextReturnType>
+
+const encode = (
+  client: ClientWithEns,
+  { name, key }: GetTextRecordParameters,
+): SimpleTransactionRequest => {
+  const prData = _getText.encode(client, { name, key })
+  return universalWrapper.encode(client, { name, data: prData.data })
+}
+
+const decode = async (
+  client: ClientWithEns,
+  data: Hex | BaseError,
+  passthrough: GenericPassthrough,
+): Promise<GetTextRecordReturnType> => {
+  const urData = await universalWrapper.decode(client, data, passthrough)
+  return _getText.decode(client, urData.data)
+}
+
+type BatchableFunctionObject = GeneratedFunction<typeof encode, typeof decode>
+
+/**
+ * Gets a text record for a name.
+ * @param client - {@link ClientWithEns}
+ * @param parameters - {@link GetTextRecordParameters}
+ * @returns Text record string, or null if none is found. {@link GetTextRecordReturnType}
+ *
+ * @example
+ * import { createPublicClient, http } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { addEnsContracts, getTextRecord } from '@ensdomains/ensjs'
+ *
+ * const client = createPublicClient({
+ *   chain: addEnsContracts(mainnet),
+ *   transport: http(),
+ * })
+ * const result = await getTextRecord(client, { name: 'ens.eth', key: 'com.twitter' })
+ * // ensdomains
+ */
+const getTextRecord = generateFunction({ encode, decode }) as ((
+  client: ClientWithEns,
+  { name, key }: GetTextRecordParameters,
+) => Promise<GetTextRecordReturnType>) &
+  BatchableFunctionObject
+
+export default getTextRecord

package/src/functions/public/getWrapperData.ts

@@ -0,0 +1,128 @@
+import {
+  BaseError,
+  decodeFunctionResult,
+  encodeFunctionData,
+  getContractError,
+  type Address,
+  type Hex,
+} from 'viem'
+import type { ClientWithEns } from '../../contracts/consts.js'
+import { getChainContractAddress } from '../../contracts/getChainContractAddress.js'
+import { nameWrapperGetDataSnippet } from '../../contracts/nameWrapper.js'
+import type {
+  DateWithValue,
+  GenericPassthrough,
+  Prettify,
+  TransactionRequestWithPassthrough,
+} from '../../types.js'
+import { EMPTY_ADDRESS } from '../../utils/consts.js'
+import { decodeFuses, type DecodedFuses } from '../../utils/fuses.js'
+import {
+  generateFunction,
+  type GeneratedFunction,
+} from '../../utils/generateFunction.js'
+import { makeSafeSecondsDate } from '../../utils/makeSafeSecondsDate.js'
+import { namehash } from '../../utils/normalise.js'
+
+export type GetWrapperDataParameters = {
+  /** Name to get wrapper data for */
+  name: string
+}
+
+export type GetWrapperDataReturnType = Prettify<{
+  /** Fuse object */
+  fuses: DecodedFuses & {
+    value: number
+  }
+  /** Expiry of the name */
+  expiry: DateWithValue<bigint> | null
+  /** Owner of the name */
+  owner: Address
+} | null>
+
+const encode = (
+  client: ClientWithEns,
+  { name }: GetWrapperDataParameters,
+): TransactionRequestWithPassthrough => {
+  const address = getChainContractAddress({
+    client,
+    contract: 'ensNameWrapper',
+  })
+  const args = [BigInt(namehash(name))] as const
+  return {
+    to: address,
+    data: encodeFunctionData({
+      abi: nameWrapperGetDataSnippet,
+      functionName: 'getData',
+      args,
+    }),
+    passthrough: { address, args },
+  }
+}
+
+const decode = async (
+  _client: ClientWithEns,
+  data: Hex | BaseError,
+  passthrough: GenericPassthrough,
+): Promise<GetWrapperDataReturnType> => {
+  if (typeof data === 'object')
+    throw getContractError(data, {
+      abi: nameWrapperGetDataSnippet,
+      functionName: 'getData',
+      args: passthrough.args,
+      address: passthrough.address,
+    })
+  const [owner, fuses, expiry] = decodeFunctionResult({
+    abi: nameWrapperGetDataSnippet,
+    functionName: 'getData',
+    data,
+  })
+
+  if (owner === EMPTY_ADDRESS) {
+    return null
+  }
+
+  const fuseObj = decodeFuses(fuses)
+  const expiryDate = expiry > 0 ? makeSafeSecondsDate(expiry) : null
+
+  return {
+    fuses: {
+      ...fuseObj,
+      value: fuses,
+    },
+    expiry: expiryDate
+      ? {
+          date: expiryDate,
+          value: expiry,
+        }
+      : null,
+    owner,
+  }
+}
+
+type BatchableFunctionObject = GeneratedFunction<typeof encode, typeof decode>
+
+/**
+ * Gets the wrapper data for a name.
+ * @param client - {@link ClientWithEns}
+ * @param parameters - {@link GetWrapperDataParameters}
+ * @returns Wrapper data object, or null if name is not wrapped. {@link GetWrapperDataReturnType}
+ *
+ * @example
+ * import { createPublicClient, http } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { addEnsContracts, getWrapperData } from '@ensdomains/ensjs'
+ *
+ * const client = createPublicClient({
+ *   chain: addEnsContracts(mainnet),
+ *   transport: http(),
+ * })
+ * const result = await getWrapperData(client, { name: 'ilikelasagna.eth' })
+ */
+const getWrapperData = generateFunction({ encode, decode }) as ((
+  client: ClientWithEns,
+  { name }: GetWrapperDataParameters,
+) => Promise<GetWrapperDataReturnType>) &
+  BatchableFunctionObject
+
+export default getWrapperData

package/src/functions/public/getWrapperName.ts

@@ -0,0 +1,97 @@
+import {
+  BaseError,
+  decodeFunctionResult,
+  encodeFunctionData,
+  getContractError,
+  hexToBytes,
+  type Hex,
+} from 'viem'
+import type { ClientWithEns } from '../../contracts/consts.js'
+import { getChainContractAddress } from '../../contracts/getChainContractAddress.js'
+import { nameWrapperNamesSnippet } from '../../contracts/nameWrapper.js'
+import type {
+  GenericPassthrough,
+  TransactionRequestWithPassthrough,
+} from '../../types.js'
+import {
+  generateFunction,
+  type GeneratedFunction,
+} from '../../utils/generateFunction.js'
+import { bytesToPacket } from '../../utils/hexEncodedName.js'
+import { namehash } from '../../utils/normalise.js'
+
+export type GetWrapperNameParameters = {
+  /** Name with unknown labels, e.g. "[4ca938ec1b323ca71c4fb47a712abb68cce1cabf39ea4d6789e42fbc1f95459b].eth" */
+  name: string
+}
+
+export type GetWrapperNameReturnType = string | null
+
+const encode = (
+  client: ClientWithEns,
+  { name }: GetWrapperNameParameters,
+): TransactionRequestWithPassthrough => {
+  const address = getChainContractAddress({
+    client,
+    contract: 'ensNameWrapper',
+  })
+  const args = [namehash(name)] as const
+  return {
+    to: address,
+    data: encodeFunctionData({
+      abi: nameWrapperNamesSnippet,
+      functionName: 'names',
+      args,
+    }),
+    passthrough: { address, args },
+  }
+}
+
+const decode = async (
+  _client: ClientWithEns,
+  data: Hex | BaseError,
+  passthrough: GenericPassthrough,
+): Promise<GetWrapperNameReturnType> => {
+  if (typeof data === 'object')
+    throw getContractError(data, {
+      abi: nameWrapperNamesSnippet,
+      functionName: 'names',
+      args: passthrough.args,
+      address: passthrough.address,
+    })
+  const result = decodeFunctionResult({
+    abi: nameWrapperNamesSnippet,
+    functionName: 'names',
+    data,
+  })
+  if (!result || result === '0x' || BigInt(result) === 0n) return null
+  return bytesToPacket(hexToBytes(result))
+}
+
+type BatchableFunctionObject = GeneratedFunction<typeof encode, typeof decode>
+
+/**
+ * Gets the full name for a name with unknown labels from the NameWrapper.
+ * @param client - {@link ClientWithEns}
+ * @param parameters - {@link GetWrapperNameParameters}
+ * @returns Full name, or null if name was not found. {@link GetWrapperNameReturnType}
+ *
+ * @example
+ * import { createPublicClient, http } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { addEnsContracts, getWrapperName } from '@ensdomains/ensjs'
+ *
+ * const client = createPublicClient({
+ *   chain: addEnsContracts(mainnet),
+ *   transport: http(),
+ * })
+ * const result = await getWrapperName(client, { name: '[4ca938ec1b323ca71c4fb47a712abb68cce1cabf39ea4d6789e42fbc1f95459b].eth' })
+ * // wrapped.eth
+ */
+const getWrapperName = generateFunction({ encode, decode }) as ((
+  client: ClientWithEns,
+  { name }: GetWrapperNameParameters,
+) => Promise<GetWrapperNameReturnType>) &
+  BatchableFunctionObject
+
+export default getWrapperName

package/src/functions/public/multicallWrapper.ts

@@ -0,0 +1,88 @@
+import {
+  BaseError,
+  decodeFunctionResult,
+  encodeFunctionData,
+  getContractError,
+  offchainLookup,
+  type Hex,
+} from 'viem'
+import type { ClientWithEns } from '../../contracts/consts.js'
+import { getChainContractAddress } from '../../contracts/getChainContractAddress.js'
+import { multicallTryAggregateSnippet } from '../../contracts/multicall.js'
+import type {
+  SimpleTransactionRequest,
+  TransactionRequestWithPassthrough,
+} from '../../types.js'
+import { generateFunction } from '../../utils/generateFunction.js'
+
+export type MulticallWrapperParameters = {
+  transactions: SimpleTransactionRequest[]
+  requireSuccess?: boolean
+}
+
+export type MulticallWrapperReturnType = {
+  success: boolean
+  returnData: Hex
+}[]
+
+const encode = (
+  client: ClientWithEns,
+  { transactions, requireSuccess = false }: MulticallWrapperParameters,
+): SimpleTransactionRequest => {
+  return {
+    to: getChainContractAddress({ client, contract: 'multicall3' }),
+    data: encodeFunctionData({
+      abi: multicallTryAggregateSnippet,
+      functionName: 'tryAggregate',
+      args: [
+        requireSuccess,
+        transactions.map((tx) => ({ target: tx.to!, callData: tx.data! })),
+      ],
+    }),
+  }
+}
+
+const decode = async (
+  client: ClientWithEns,
+  data: Hex | BaseError,
+  transactions: TransactionRequestWithPassthrough[],
+): Promise<MulticallWrapperReturnType> => {
+  if (typeof data === 'object') {
+    throw getContractError(data, {
+      abi: multicallTryAggregateSnippet,
+      functionName: 'tryAggregate',
+      args: [],
+    })
+  }
+  const result = decodeFunctionResult({
+    abi: multicallTryAggregateSnippet,
+    functionName: 'tryAggregate',
+    data,
+  })
+  const ccipChecked = await Promise.all(
+    result.map(async ({ success, returnData }, i) => {
+      let newObj: { success: boolean; returnData: Hex } = {
+        success,
+        returnData,
+      }
+      // OffchainLookup(address,string[],bytes,bytes4,bytes)
+      if (!success && returnData.startsWith('0x556f1830')) {
+        try {
+          const newData = await offchainLookup(client, {
+            to: transactions[i].to!,
+            data: returnData,
+          })
+          if (newData) {
+            newObj = { success: true, returnData: newData }
+          }
+        } catch {}
+      }
+      return newObj
+    }),
+  )
+  return ccipChecked
+}
+
+const multicallWrapper = generateFunction({ encode, decode })
+
+export default multicallWrapper

package/src/functions/public/universalWrapper.ts

@@ -0,0 +1,108 @@
+import {
+  BaseError,
+  decodeErrorResult,
+  decodeFunctionResult,
+  encodeFunctionData,
+  getContractError,
+  labelhash,
+  toBytes,
+  toHex,
+  type Address,
+  type Hex,
+} from 'viem'
+import type { ClientWithEns } from '../../contracts/consts.js'
+import { getChainContractAddress } from '../../contracts/getChainContractAddress.js'
+import { universalResolverResolveSnippet } from '../../contracts/universalResolver.js'
+import type {
+  GenericPassthrough,
+  TransactionRequestWithPassthrough,
+} from '../../types.js'
+import { EMPTY_ADDRESS } from '../../utils/consts.js'
+import { generateFunction } from '../../utils/generateFunction.js'
+import { getRevertErrorData } from '../../utils/getRevertErrorData.js'
+import { packetToBytes } from '../../utils/hexEncodedName.js'
+import { encodeLabelhash } from '../../utils/labels.js'
+
+export type UniversalWrapperParameters = {
+  name: string
+  data: Hex
+}
+
+export type UniversalWrapperReturnType = {
+  data: Hex
+  resolver: Address
+}
+
+const encode = (
+  client: ClientWithEns,
+  { name, data }: UniversalWrapperParameters,
+): 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: getChainContractAddress({ client, contract: 'ensUniversalResolver' }),
+    data: encodeFunctionData({
+      abi: universalResolverResolveSnippet,
+      functionName: 'resolve',
+      args,
+    }),
+    passthrough: {
+      args,
+      address: to,
+    },
+  }
+}
+
+const decode = async (
+  _client: ClientWithEns,
+  data: Hex | BaseError,
+  passthrough: GenericPassthrough,
+): Promise<UniversalWrapperReturnType> => {
+  if (typeof data === 'object') {
+    const errorData = getRevertErrorData(data)
+    if (errorData) {
+      const decodedError = decodeErrorResult({
+        abi: universalResolverResolveSnippet,
+        data: errorData,
+      })
+      if (
+        decodedError.errorName === 'ResolverNotFound' ||
+        decodedError.errorName === 'ResolverWildcardNotSupported'
+      )
+        return {
+          data: '0x',
+          resolver: EMPTY_ADDRESS,
+        }
+    }
+    throw getContractError(data, {
+      abi: universalResolverResolveSnippet,
+      functionName: 'resolve',
+      args: passthrough.args,
+      address: passthrough.address,
+    })
+  }
+
+  const result = decodeFunctionResult({
+    abi: universalResolverResolveSnippet,
+    functionName: 'resolve',
+    data,
+  })
+  return { data: result[0], resolver: result[1] }
+}
+
+const universalWrapper = generateFunction({ encode, decode })
+
+export default universalWrapper

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,
+  })