@ensdomains/ensjs 4.1.1 → 5.0.0-alpha.0

package/src/actions/public/getRecords.ts

@@ -0,0 +1,398 @@
+import {
+  type Abi,
+  type Address,
+  type Chain,
+  type EncodeFunctionDataErrorType,
+  encodeFunctionData,
+  type Hex,
+  type MulticallErrorType,
+  zeroAddress,
+} from 'viem'
+import { multicall } from 'viem/actions'
+import { getAction } from 'viem/utils'
+import type { RequireClientContracts } from '../../clients/chain.js'
+import type { ErrorType } from '../../errors/utils.js'
+import type { DecodedAddr, DecodedText, Prettify } from '../../types/index.js'
+import { ASSERT_NO_TYPE_ERROR } from '../../types/internal.js'
+import {
+  type DecodeAbiResultErrorType,
+  type DecodeAbiResultFromPrimitiveTypesErrorType,
+  type DecodeAbiResultReturnType,
+  decodeAbiResult,
+  decodeAbiResultFromPrimitiveTypes,
+  type GetAbiParametersErrorType,
+  getAbiParameters,
+} from '../../utils/coders/getAbi.js'
+import {
+  type DecodeAddressResultErrorType,
+  type DecodeAddressResultFromPrimitiveTypesErrorType,
+  decodeAddressResult,
+  decodeAddressResultFromPrimitiveTypes,
+  type GetAddressParametersErrorType,
+  getAddressParameters,
+} from '../../utils/coders/getAddress.js'
+import {
+  type DecodeContentHashResultErrorType,
+  type DecodeContentHashResultFromPrimitiveTypesErrorType,
+  decodeContentHashResult,
+  decodeContentHashResultFromPrimitiveTypes,
+  type GetContentHashErrorType,
+  type GetContentHashReturnType,
+  getContentHashParameters,
+} from '../../utils/coders/getContentHash.js'
+import {
+  type DecodeTextResultErrorType,
+  type DecodeTextResultFromPrimitiveTypesErrorType,
+  decodeTextResult,
+  decodeTextResultFromPrimitiveTypes,
+  type GetTextParametersErrorType,
+  getTextParameters,
+} from '../../utils/coders/getText.js'
+import {
+  type ResolveNameDataErrorType,
+  resolveNameData,
+} from './resolveNameData.js'
+
+export type GetRecordsParameters<
+  texts extends readonly string[] | undefined = readonly string[],
+  coins extends readonly (string | number)[] | undefined = readonly (
+    | string
+    | number
+  )[],
+  contentHash extends boolean | undefined = true,
+  abi extends boolean | undefined = true,
+> = {
+  /** Name to get records for */
+  name: string
+  /** Text record key array */
+  texts?: texts
+  /** Coin record id/symbol array */
+  coins?: coins
+  /** If true, will fetch content hash */
+  contentHash?: contentHash
+  /** If true, will fetch ABI */
+  abi?: abi
+  /** Optional specific resolver address, for fallback or for all results */
+  resolver?: {
+    /** Resolver address */
+    address: Address
+    /** If true, will only use resolver if main fetch fails */
+    fallbackOnly?: boolean
+  }
+  /** Batch gateway URLs to use for resolving CCIP-read requests. */
+  gatewayUrls?: string[]
+}
+
+type WithContentHashResult = {
+  /** Retrieved content hash record for name */
+  contentHash: GetContentHashReturnType
+}
+
+type WithAbiResult = {
+  /** Retrieved ABI record for name */
+  abi: DecodeAbiResultReturnType
+}
+
+type WithTextsResult = {
+  /** Retrieved text records for name */
+  texts: DecodedText[]
+}
+
+type WithCoinsResult = {
+  /** Retrieved coins for name */
+  coins: DecodedAddr[]
+}
+
+type CreateCallsErrorType =
+  | GetTextParametersErrorType
+  | DecodeTextResultFromPrimitiveTypesErrorType
+  | DecodeTextResultErrorType
+  | GetAddressParametersErrorType
+  | DecodeAddressResultFromPrimitiveTypesErrorType
+  | DecodeAddressResultErrorType
+  | GetContentHashErrorType
+  | DecodeContentHashResultFromPrimitiveTypesErrorType
+  | DecodeContentHashResultErrorType
+  | GetAbiParametersErrorType
+  | DecodeAbiResultFromPrimitiveTypesErrorType
+  | DecodeAbiResultErrorType
+
+const createCalls = <
+  const texts extends readonly string[] | undefined = undefined,
+  const coins extends readonly (string | number)[] | undefined = undefined,
+  const contentHash extends boolean | undefined = undefined,
+  const abi extends boolean | undefined = undefined,
+>({
+  name,
+  texts,
+  coins,
+  abi,
+  contentHash,
+}: Pick<
+  GetRecordsParameters<texts, coins, contentHash, abi>,
+  'name' | 'texts' | 'coins' | 'abi' | 'contentHash'
+>) => [
+  ...(texts ?? []).map(
+    (text) =>
+      ({
+        parameters: getTextParameters({ name, key: text }),
+        addToResult: <shouldDecodeFromPrimitiveTypes extends boolean>({
+          currentResult,
+          data,
+          shouldDecodeFromPrimitiveTypes,
+        }: {
+          currentResult: GetRecordsReturnType
+          shouldDecodeFromPrimitiveTypes: shouldDecodeFromPrimitiveTypes
+          data: shouldDecodeFromPrimitiveTypes extends true ? string : Hex
+        }) => {
+          const result = shouldDecodeFromPrimitiveTypes
+            ? decodeTextResultFromPrimitiveTypes({ decodedData: data })
+            : decodeTextResult(data as Hex, { strict: false })
+          if (!result) return
+
+          currentResult.texts.push({ key: text, value: result })
+        },
+      }) as const,
+  ),
+  ...(coins ?? []).map(
+    (coin) =>
+      ({
+        parameters: getAddressParameters({ name, coin }),
+        addToResult: <shouldDecodeFromPrimitiveTypes extends boolean>({
+          currentResult,
+          data,
+          shouldDecodeFromPrimitiveTypes,
+        }: {
+          currentResult: GetRecordsReturnType
+          shouldDecodeFromPrimitiveTypes: shouldDecodeFromPrimitiveTypes
+          data: Hex
+        }) => {
+          try {
+            const result = shouldDecodeFromPrimitiveTypes
+              ? decodeAddressResultFromPrimitiveTypes({
+                  decodedData: data,
+                  coin,
+                })
+              : decodeAddressResult(data, { coin, strict: false })
+
+            if (!result) return
+
+            currentResult.coins.push(result)
+          } catch (e) {
+            console.error(e)
+            // Don't panic if coming across an unknown coinType
+            return
+          }
+        },
+      }) as const,
+  ),
+  ...(contentHash
+    ? ([
+        {
+          parameters: getContentHashParameters({ name }),
+          addToResult: <shouldDecodeFromPrimitiveTypes extends boolean>({
+            currentResult,
+            data,
+            shouldDecodeFromPrimitiveTypes,
+          }: {
+            currentResult: GetRecordsReturnType
+            shouldDecodeFromPrimitiveTypes: shouldDecodeFromPrimitiveTypes
+            data: Hex
+          }) => {
+            const result = shouldDecodeFromPrimitiveTypes
+              ? decodeContentHashResultFromPrimitiveTypes({ decodedData: data })
+              : decodeContentHashResult(data, { strict: false })
+            if (!result) return
+
+            currentResult.contentHash = result
+          },
+        },
+      ] as const)
+    : []),
+  ...(abi
+    ? ([
+        {
+          parameters: getAbiParameters({ name }),
+          addToResult: async <shouldDecodeFromPrimitiveTypes extends boolean>({
+            currentResult,
+            data,
+            shouldDecodeFromPrimitiveTypes,
+          }: {
+            currentResult: GetRecordsReturnType
+            shouldDecodeFromPrimitiveTypes: shouldDecodeFromPrimitiveTypes
+            data: shouldDecodeFromPrimitiveTypes extends true
+              ? readonly [bigint, Hex]
+              : Hex
+          }) => {
+            const result = shouldDecodeFromPrimitiveTypes
+              ? await decodeAbiResultFromPrimitiveTypes({
+                  decodedData: data as readonly [bigint, Hex],
+                })
+              : await decodeAbiResult(data as Hex, { strict: false })
+            if (!result) return
+
+            currentResult.abi = result
+          },
+        },
+      ] as const)
+    : []),
+]
+
+const createEmptyResult = <
+  texts extends readonly string[] | undefined,
+  coins extends readonly (string | number)[] | undefined,
+  contentHash extends boolean | undefined,
+  abi extends boolean | undefined,
+>({
+  texts,
+  coins,
+  abi,
+  contentHash,
+}: Pick<
+  GetRecordsParameters<texts, coins, contentHash, abi>,
+  'texts' | 'coins' | 'abi' | 'contentHash'
+>) =>
+  ({
+    ...(texts ? { texts: [] as DecodedText[] } : {}),
+    ...(coins ? { coins: [] as DecodedAddr[] } : {}),
+    ...(contentHash ? { contentHash: null } : {}),
+    ...(abi ? { abi: null } : {}),
+    resolverAddress: zeroAddress as Address,
+  }) as GetRecordsReturnType
+
+export type GetRecordsReturnType<
+  texts extends readonly string[] | undefined = readonly string[],
+  coins extends readonly (string | number)[] | undefined = readonly (
+    | string
+    | number
+  )[],
+  contentHash extends boolean | undefined = true,
+  abi extends boolean | undefined = true,
+> = Prettify<
+  (contentHash extends true ? WithContentHashResult : {}) &
+    (abi extends true ? WithAbiResult : {}) &
+    (texts extends readonly string[] ? WithTextsResult : {}) &
+    (coins extends readonly (string | number)[] ? WithCoinsResult : {}) & {
+      /** Resolver address used for fetch */
+      resolverAddress: Address
+    }
+>
+
+export type GetRecordsErrorType =
+  | CreateCallsErrorType
+  | MulticallErrorType
+  | ResolveNameDataErrorType
+  | EncodeFunctionDataErrorType
+  | ErrorType
+
+/**
+ * Gets arbitrary records for a name
+ * @param client - {@link Client}
+ * @param parameters - {@link GetRecordsParameters}
+ * @returns Records data object. {@link GetRecordsReturnType}
+ *
+ * @example
+ * import { createPublicClient, http } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { addEnsContracts } from '@ensdomains/ensjs'
+ * import { getRecords } from '@ensdomains/ensjs/public'
+ *
+ * const client = createPublicClient({
+ *   chain: addEnsContracts(mainnet),
+ *   transport: http(),
+ * })
+ * const result = await getRecords(client, {
+ *   name: 'ens.eth',
+ *   texts: ['com.twitter', 'com.github'],
+ *   coins: ['ETH'],
+ *   contentHash: true,
+ * })
+ * // { texts: [{ key: 'com.twitter', value: 'ensdomains' }, { key: 'com.github', value: 'ensdomains' }], coins: [{ id: 60, name: 'ETH', value: '0xFe89cc7aBB2C4183683ab71653C4cdc9B02D44b7' }], contentHash: { protocolType: 'ipns', decoded: 'k51qzi5uqu5djdczd6zw0grmo23j2vkj9uzvujencg15s5rlkq0ss4ivll8wqw' } }
+ */
+export async function getRecords<
+  chain extends Chain,
+  const texts extends readonly string[] | undefined = undefined,
+  const coins extends readonly (string | number)[] | undefined = undefined,
+  const contentHash extends boolean | undefined = undefined,
+  const abi extends boolean | undefined = undefined,
+>(
+  client: RequireClientContracts<chain, 'ensUniversalResolver' | 'multicall3'>,
+  {
+    name,
+    resolver,
+    texts,
+    coins,
+    contentHash,
+    abi,
+    gatewayUrls,
+  }: GetRecordsParameters<texts, coins, contentHash, abi>,
+): Promise<GetRecordsReturnType<texts, coins, contentHash, abi>> {
+  ASSERT_NO_TYPE_ERROR(client)
+
+  const calls = createCalls({
+    name,
+    texts,
+    coins,
+    contentHash,
+    abi,
+  })
+  const currentResult = createEmptyResult({ texts, coins, contentHash, abi })
+
+  if (resolver?.address && !resolver.fallbackOnly) {
+    const multicallAction = getAction(client, multicall, 'multicall')
+    const result = await multicallAction({
+      contracts: calls.map((c) => ({
+        address: resolver.address,
+        ...c.parameters,
+      })),
+    })
+    currentResult.resolverAddress = resolver.address
+    await Promise.all(
+      result.map(async (item, i) => {
+        if (item.status !== 'success') return
+
+        const callItem = calls[i]
+        await callItem.addToResult({
+          currentResult,
+          data: item.result as never,
+          shouldDecodeFromPrimitiveTypes: true,
+        })
+      }),
+    )
+  } else {
+    const resolveNameDataAction = getAction(
+      client,
+      resolveNameData,
+      'resolveNameData',
+    )
+    const result = await resolveNameDataAction({
+      name,
+      data: calls.map((c) => encodeFunctionData<Abi>(c?.parameters)),
+      gatewayUrls,
+    })
+    if (!result)
+      return currentResult as GetRecordsReturnType<
+        texts,
+        coins,
+        contentHash,
+        abi
+      >
+
+    currentResult.resolverAddress = result.resolverAddress
+
+    await Promise.all(
+      result.resolvedData.map(async (item, i) => {
+        if (!item.success) return
+
+        const callItem = calls[i]
+        await callItem.addToResult({
+          currentResult,
+          data: item.returnData,
+          shouldDecodeFromPrimitiveTypes: false,
+        })
+      }),
+    )
+  }
+
+  return currentResult as GetRecordsReturnType<texts, coins, contentHash, abi>
+}

package/src/actions/public/getResolver.ts

@@ -0,0 +1,71 @@
+import {
+  type Address,
+  type Chain,
+  type GetChainContractAddressErrorType,
+  type ReadContractErrorType,
+  type ToHexErrorType,
+  toHex,
+  zeroAddress,
+} from 'viem'
+import { readContract } from 'viem/actions'
+import { type PacketToBytesErrorType, packetToBytes } from 'viem/ens'
+import { getAction } from 'viem/utils'
+import {
+  getChainContractAddress,
+  type RequireClientContracts,
+} from '../../clients/chain.js'
+import { universalResolverFindResolverSnippet } from '../../contracts/universalResolver.js'
+import { ASSERT_NO_TYPE_ERROR } from '../../types/internal.js'
+
+export type GetResolverParameters = {
+  /** Name to get resolver for */
+  name: string
+}
+
+export type GetResolverReturnType = Address | null
+
+export type GetResolverErrorType =
+  | ReadContractErrorType
+  | GetChainContractAddressErrorType
+  | ToHexErrorType
+  | PacketToBytesErrorType
+
+/**
+ * Gets the resolver address for a name.
+ * @param client - {@link Client}
+ * @param parameters - {@link GetResolverParameters}
+ * @returns Resolver address, or null if none is found. {@link GetResolverReturnType}
+ *
+ * @example
+ * import { createPublicClient, http } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { addEnsContracts } from '@ensdomains/ensjs'
+ * import { getResolver } from '@ensdomains/ensjs/public'
+ *
+ * const client = createPublicClient({
+ *   chain: addEnsContracts(mainnet),
+ *   transport: http(),
+ * })
+ * const result = await getResolver(client, { name: 'ens.eth' })
+ * // 0x4976fb03C32e5B8cfe2b6cCB31c09Ba78EBaBa41
+ */
+export async function getResolver<chain extends Chain>(
+  client: RequireClientContracts<chain, 'ensUniversalResolver'>,
+  { name }: GetResolverParameters,
+): Promise<GetResolverReturnType> {
+  ASSERT_NO_TYPE_ERROR(client)
+
+  const readContractAction = getAction(client, readContract, 'readContract')
+  const result = await readContractAction({
+    address: getChainContractAddress({
+      chain: client.chain,
+      contract: 'ensUniversalResolver',
+    }),
+    abi: universalResolverFindResolverSnippet,
+    functionName: 'findResolver',
+    args: [toHex(packetToBytes(name))],
+  })
+
+  if (result[0] === zeroAddress) return null
+  return result[0]
+}

package/src/actions/public/getSupportedInterfaces.ts

@@ -0,0 +1,68 @@
+import type { Address, Chain, Hex, MulticallErrorType } from 'viem'
+import { multicall } from 'viem/actions'
+import { getAction } from 'viem/utils'
+import type { RequireClientContracts } from '../../clients/chain.js'
+import { erc165SupportsInterfaceSnippet } from '../../contracts/erc165.js'
+import { ASSERT_NO_TYPE_ERROR } from '../../types/internal.js'
+
+export type GetSupportedInterfacesParameters<
+  interfaces extends readonly Hex[],
+> = {
+  address: Address
+  interfaces: interfaces
+}
+
+export type GetSupportedInterfacesReturnType<
+  interfaces extends readonly Hex[],
+> = {
+  -readonly [K in keyof interfaces]: boolean
+}
+
+export type GetSupportedInterfacesErrorType = MulticallErrorType
+
+/**
+ * Gets the supported interfaces for any contract address.
+ * @param client - {@link Client}
+ * @param parameters - {@link GetSupportedInterfacesParameters}
+ * @returns Array of booleans matching the input array {@link GetSupportedInterfacesReturnType}
+ *
+ * @example
+ * import { createPublicClient, http } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { addEnsContracts } from '@ensdomains/ensjs'
+ * import { getSupportedInterfaces } from '@ensdomains/ensjs/public'
+ *
+ * const client = createPublicClient({
+ *   chain: addEnsContracts(mainnet),
+ *   transport: http(),
+ * })
+ * const result = await getSupportedInterfaces(client, {
+ *   address: '0x58774Bb8acD458A640aF0B88238369A167546ef2',
+ *   interfaces: ['0x2f435428', '0x23b872dd'],
+ * })
+ * // [true, false]
+ */
+export async function getSupportedInterfaces<
+  chain extends Chain,
+  const interfaces extends readonly Hex[],
+>(
+  client: RequireClientContracts<chain, 'multicall3'>,
+  { address, interfaces }: GetSupportedInterfacesParameters<interfaces>,
+): Promise<GetSupportedInterfacesReturnType<interfaces>> {
+  ASSERT_NO_TYPE_ERROR(client)
+
+  const multicallAction = getAction(client, multicall, 'multicall')
+
+  const result = await multicallAction({
+    contracts: interfaces.map((interfaceId) => ({
+      address,
+      abi: erc165SupportsInterfaceSnippet,
+      functionName: 'supportsInterface',
+      args: [interfaceId],
+    })),
+  })
+
+  return result.map(
+    (r) => r.status === 'success' && r.result === true,
+  ) as GetSupportedInterfacesReturnType<interfaces>
+}

package/src/actions/public/getTextRecord.ts

@@ -0,0 +1,74 @@
+import type { Chain, EncodeFunctionDataErrorType } from 'viem'
+import { encodeFunctionData, getAction } from 'viem/utils'
+import type { RequireClientContracts } from '../../clients/chain.js'
+import type { Prettify } from '../../types/index.js'
+import { ASSERT_NO_TYPE_ERROR } from '../../types/internal.js'
+import {
+  type DecodeTextResultErrorType,
+  type DecodeTextResultParameters,
+  type DecodeTextResultReturnType,
+  decodeTextResult,
+  type GetTextParametersErrorType,
+  type GetTextParametersParameters,
+  getTextParameters,
+} from '../../utils/coders/getText.js'
+import {
+  type ResolveNameDataErrorType,
+  resolveNameData,
+} from './resolveNameData.js'
+
+export type GetTextRecordParameters = Prettify<
+  GetTextParametersParameters &
+    DecodeTextResultParameters & {
+      /** Batch gateway URLs to use for resolving CCIP-read requests. */
+      gatewayUrls?: string[]
+    }
+>
+
+export type GetTextRecordReturnType = DecodeTextResultReturnType
+
+export type GetTextRecordErrorType =
+  | ResolveNameDataErrorType
+  | EncodeFunctionDataErrorType
+  | GetTextParametersErrorType
+  | DecodeTextResultErrorType
+
+/**
+ * Gets a text record for a name.
+ * @param client - {@link Client}
+ * @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 } from '@ensdomains/ensjs'
+ * import { getTextRecord } from '@ensdomains/ensjs/public'
+ *
+ * const client = createPublicClient({
+ *   chain: addEnsContracts(mainnet),
+ *   transport: http(),
+ * })
+ * const result = await getTextRecord(client, { name: 'ens.eth', key: 'com.twitter' })
+ * // ensdomains
+ */
+export async function getTextRecord<chain extends Chain>(
+  client: RequireClientContracts<chain, 'ensUniversalResolver'>,
+  { gatewayUrls, strict, ...parameters }: GetTextRecordParameters,
+): Promise<GetTextRecordReturnType> {
+  ASSERT_NO_TYPE_ERROR(client)
+
+  const resolveNameDataAction = getAction(
+    client,
+    resolveNameData,
+    'resolveNameData',
+  )
+  const result = await resolveNameDataAction({
+    name: parameters.name,
+    data: encodeFunctionData(getTextParameters(parameters)),
+    gatewayUrls,
+    strict,
+  })
+  if (!result) return null
+  return decodeTextResult(result.resolvedData, { strict })
+}

package/src/actions/public/getWrapperData.ts

@@ -0,0 +1,88 @@
+import {
+  type Address,
+  type Chain,
+  type GetChainContractAddressErrorType,
+  type NamehashErrorType,
+  namehash,
+  type ReadContractErrorType,
+  zeroAddress,
+} from 'viem'
+import { readContract } from 'viem/actions'
+import { getAction } from 'viem/utils'
+import {
+  getChainContractAddress,
+  type RequireClientContracts,
+} from '../../clients/chain.js'
+import { nameWrapperGetDataSnippet } from '../../contracts/nameWrapper.js'
+import type { Prettify } from '../../types/index.js'
+import { ASSERT_NO_TYPE_ERROR } from '../../types/internal.js'
+import { type DecodedFuses, decodeFuses } from '../../utils/fuses.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: bigint | null
+  /** Owner of the name */
+  owner: Address
+} | null>
+
+export type GetWrapperDataErrorType =
+  | ReadContractErrorType
+  | GetChainContractAddressErrorType
+  | NamehashErrorType
+
+/**
+ * Gets the wrapper data for a name.
+ * @param client - {@link Client}
+ * @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 } from '@ensdomains/ensjs'
+ * import { getWrapperData } from '@ensdomains/ensjs/public'
+ *
+ * const client = createPublicClient({
+ *   chain: addEnsContracts(mainnet),
+ *   transport: http(),
+ * })
+ * const result = await getWrapperData(client, { name: 'ilikelasagna.eth' })
+ */
+export async function getWrapperData<chain extends Chain>(
+  client: RequireClientContracts<chain, 'ensNameWrapper'>,
+  { name }: GetWrapperDataParameters,
+): Promise<GetWrapperDataReturnType> {
+  ASSERT_NO_TYPE_ERROR(client)
+
+  const readContractAction = getAction(client, readContract, 'readContract')
+  const [owner, fuses, expiry] = await readContractAction({
+    address: getChainContractAddress({
+      chain: client.chain,
+      contract: 'ensNameWrapper',
+    }),
+    abi: nameWrapperGetDataSnippet,
+    functionName: 'getData',
+    args: [BigInt(namehash(name))],
+  })
+
+  if (owner === zeroAddress) return null
+
+  const fuseObj = decodeFuses(fuses)
+  return {
+    fuses: {
+      ...fuseObj,
+      value: fuses,
+    },
+    expiry: expiry > 0 ? expiry * 1000n : null,
+    owner,
+  }
+}