@ensdomains/ensjs 4.1.1 → 5.0.0-alpha.0

package/src/utils/coders/getAbi.ts

@@ -0,0 +1,211 @@
+import {
+  type DecodeFunctionResultErrorType,
+  decodeFunctionResult,
+  type Hex,
+  type HexToBytesErrorType,
+  type HexToStringErrorType,
+  hexToBytes,
+  hexToString,
+  type NamehashErrorType,
+  namehash,
+  type TrimErrorType,
+  trim,
+} from 'viem'
+import { publicResolverAbiSnippet } from '../../contracts/publicResolver.js'
+import type { ErrorType } from '../../errors/utils.js'
+import type { DecodedAbi, Prettify } from '../../types/index.js'
+
+/** @deprecated */
+export type GetAbiParameters = {
+  /** Name to get ABI record for */
+  name: string
+  /** Supported content types as bitwise
+   * ID 1: JSON
+   * ID 2: zlib compressed JSON
+   * ID 4: CBOR
+   * ID 8: URI
+   */
+  supportedContentTypes?: bigint | undefined
+  /** Whether or not to throw decoding errors */
+  strict?: boolean | undefined
+}
+
+/**
+ * @deprecated
+ */
+export type GetAbiReturnType = Prettify<DecodedAbi | null>
+
+/**
+ * @deprecated
+ */
+export type GetAbiErrorType = Error
+
+// ================================
+// Get ABI parameters
+// ================================
+
+export type GetAbiParametersParameters = {
+  /** Name to get ABI record for */
+  name: string
+  /** Supported content types as bitwise
+   * ID 1: JSON
+   * ID 2: zlib compressed JSON
+   * ID 4: CBOR
+   * ID 8: URI
+   */
+  supportedContentTypes?: bigint | undefined
+}
+
+export type GetAbiParametersReturnType = {
+  abi: typeof publicResolverAbiSnippet
+  functionName: 'ABI'
+  args: readonly [Hex, bigint]
+}
+
+export type GetAbiParametersErrorType = NamehashErrorType
+
+export function getAbiParameters({
+  name,
+  supportedContentTypes = 0xfn,
+}: GetAbiParametersParameters): GetAbiParametersReturnType {
+  return {
+    abi: publicResolverAbiSnippet,
+    functionName: 'ABI',
+    args: [namehash(name), supportedContentTypes],
+  } as const
+}
+
+// ================================
+// Decode ABI result from primitive types
+// ================================
+
+export type DecodeAbiResultFromPrimitiveTypesParameters = {
+  decodedData: readonly [bigint, Hex]
+}
+
+export type DecodeAbiResultFromPrimitiveTypesReturnType =
+  Prettify<DecodedAbi | null>
+
+export type DecodeAbiResultFromPrimitiveTypesErrorType =
+  | TrimErrorType
+  | HexToStringErrorType
+  | HexToBytesErrorType
+  | ErrorType
+
+export async function decodeAbiResultFromPrimitiveTypes({
+  decodedData: [bigintContentType, encodedAbiData],
+}: DecodeAbiResultFromPrimitiveTypesParameters): Promise<DecodeAbiResultFromPrimitiveTypesReturnType> {
+  if (!bigintContentType || !encodedAbiData) return null
+
+  const contentType = Number(bigintContentType)
+  if (!contentType) return null
+
+  if (
+    encodedAbiData === '0x' ||
+    encodedAbiData === '0x0' ||
+    // may throw TrimErrorType
+    trim(encodedAbiData) === '0x00'
+  )
+    return null
+
+  let abiData: string | object
+  let decoded = false
+  switch (contentType) {
+    // JSON
+    case 1:
+      // may throw Error
+      abiData = JSON.parse(
+        // may throw HexToStringErrorType
+        hexToString(encodedAbiData),
+      )
+      decoded = true
+      break
+    // zlib compressed JSON
+    case 2: {
+      const { inflate } = await import('pako/dist/pako_inflate.min.js')
+      abiData = JSON.parse(
+        // external without error types but may throw Error
+        inflate(
+          // may throw HexToBytesErrorType
+          hexToBytes(encodedAbiData),
+          { to: 'string' },
+        ),
+      )
+      decoded = true
+      break
+    }
+    // CBOR
+    case 4: {
+      const { cborDecode } = await import('@ensdomains/address-encoder/utils')
+      // may throw Error
+      abiData = await cborDecode(
+        // may throw HexToBytesErrorType
+        hexToBytes(encodedAbiData).buffer,
+      )
+      decoded = true
+      break
+    }
+    // URI
+    case 8:
+      // may throw HexToStringErrorType
+      abiData = hexToString(encodedAbiData)
+      decoded = true
+      break
+    default:
+      try {
+        // may throw HexToStringErrorType
+        abiData = hexToString(encodedAbiData)
+        decoded = true
+      } catch {
+        abiData = encodedAbiData
+      }
+  }
+
+  return {
+    contentType,
+    decoded,
+    abi: abiData,
+  }
+}
+
+// ================================
+// Decode ABI result
+// ================================
+
+export type DecodeAbiResultParameters = {
+  /** Whether or not to throw decoding errors */
+  strict?: boolean | undefined
+}
+
+export type DecodeAbiResultReturnType = Prettify<DecodedAbi | null>
+
+export type DecodeAbiResultErrorType = DecodeFunctionResultErrorType
+/**
+ * Decodes an ABI result from a hex string.
+ * @param data - The hex string to decode.
+ * @param strict - Whether or not to throw decoding errors.
+ * @throws {DecodeAbiResultErrorType}
+ * @returns The decoded ABI result.
+ */
+export async function decodeAbiResult(
+  data: Hex,
+  { strict }: DecodeAbiResultParameters,
+): Promise<DecodeAbiResultReturnType> {
+  if (data === '0x') return null
+
+  try {
+    // may throw DecodeFunctionResultErrorType
+    const decodedData = decodeFunctionResult({
+      abi: publicResolverAbiSnippet,
+      functionName: 'ABI',
+      data,
+    })
+
+    return await decodeAbiResultFromPrimitiveTypes({
+      decodedData,
+    })
+  } catch (error) {
+    if (strict) throw error
+    return null
+  }
+}

package/src/utils/coders/getAddress.ts

@@ -0,0 +1,239 @@
+import {
+  type Address,
+  type DecodeFunctionResultErrorType,
+  decodeFunctionResult,
+  type Hex,
+  type HexToBytesErrorType,
+  hexToBytes,
+  type NamehashErrorType,
+  namehash,
+  type TrimErrorType,
+  trim,
+} from 'viem'
+import { type NormalizeErrorType, normalize } from 'viem/ens'
+import {
+  publicResolverMultiAddrSnippet,
+  publicResolverSingleAddrSnippet,
+} from '../../contracts/publicResolver.js'
+import type { ErrorType } from '../../errors/utils.js'
+import type { DecodedAddr, Prettify } from '../../types/index.js'
+import {
+  type GetCoderFromCoinErrorType,
+  getCoderFromCoin,
+} from '../normalizeCoinId.js'
+
+const defaultCoinValue = 60 as const
+
+/** @deprecated */
+export type GetAddressParameters<
+  coin extends number | string | undefined = undefined,
+> = {
+  /** Name to get the address record for */
+  name: string
+  /** Coin to get the address record for, can be either symbol (string) or coinId (number) (default: `60`) */
+  coin?: coin
+  /** Optionally return raw bytes value of address record (default: false) */
+  bypassFormat?: boolean
+  /** Whether or not to throw decoding errors */
+  strict?: boolean
+}
+
+/** @deprecated */
+export type GetAddressReturnType<
+  coin extends number | string | undefined = undefined,
+> = Prettify<ResolveCoinReturnType<
+  undefined extends coin
+    ? typeof defaultCoinValue
+    : coin extends number | string
+      ? coin
+      : string
+> | null>
+
+/** @deprecated */
+export type GetAddressErrorType = Error
+
+type ResolveCoinReturnType<coin extends number | string> = coin extends
+  | 60
+  | 'eth'
+  ? {
+      coinType: 60
+      symbol: 'eth'
+      value: Address
+    }
+  : DecodedAddr
+
+const abi = [
+  ...publicResolverSingleAddrSnippet,
+  ...publicResolverMultiAddrSnippet,
+] as const
+
+// ================================
+// Get address parameters
+// ================================
+
+export type GetAddressParametersParameters<
+  coin extends number | string | undefined = undefined,
+> = {
+  /** Name to get the address record for */
+  name: string
+  /** Coin to get the address record for, can be either symbol (string) or coinId (number) (default: `60`) */
+  coin?: coin
+  /** Optionally return raw bytes value of address record (default: false) */
+  bypassFormat?: boolean
+}
+
+export type GetAddressParametersErrorType =
+  | GetCoderFromCoinErrorType
+  | NamehashErrorType
+  | NormalizeErrorType
+
+export function getAddressParameters<
+  coin extends number | string | undefined = undefined,
+>({
+  name,
+  coin = defaultCoinValue,
+  bypassFormat,
+}: GetAddressParametersParameters<coin>) {
+  // may throw GetCoderFromCoinErrorType
+  const coder = getCoderFromCoin(coin)
+
+  if (coder.coinType === 60)
+    return {
+      abi,
+      functionName: 'addr',
+      args: [
+        // may throw NamehashErrorType
+        namehash(
+          // may throw NormalizeErrorType
+          normalize(name),
+        ),
+      ],
+    } as const
+
+  return {
+    abi,
+    functionName: 'addr',
+    args: [
+      // may throw NamehashErrorType
+      namehash(
+        // may throw NormalizeErrorType
+        normalize(name),
+      ),
+      BigInt(bypassFormat ? coin : coder.coinType),
+    ],
+  } as const
+}
+
+// ================================
+// Decode address result from primitive types
+// ================================
+
+export type DecodeAddressResultFromPrimitiveTypesParameters<
+  coin extends number | string | undefined = undefined,
+> = {
+  decodedData: Hex
+  coin: coin
+}
+
+export type DecodeAddressResultFromPrimitiveTypesReturnType<
+  coin extends number | string | undefined = undefined,
+> = Prettify<ResolveCoinReturnType<
+  undefined extends coin
+    ? typeof defaultCoinValue
+    : coin extends number | string
+      ? coin
+      : string
+> | null>
+
+export type DecodeAddressResultFromPrimitiveTypesErrorType =
+  | GetCoderFromCoinErrorType
+  | TrimErrorType
+  | HexToBytesErrorType
+  | ErrorType
+
+export function decodeAddressResultFromPrimitiveTypes<
+  coin extends number | string | undefined = undefined,
+>({
+  decodedData,
+  coin = defaultCoinValue,
+}: DecodeAddressResultFromPrimitiveTypesParameters<coin>): DecodeAddressResultFromPrimitiveTypesReturnType<coin> {
+  // may throw GetCoderFromCoinErrorType
+  const coder = getCoderFromCoin(coin)
+
+  // may throw TrimErrorType
+  const trimmed = trim(decodedData)
+  if (trimmed === '0x' || trimmed === '0x0' || trimmed === '0x00') return null
+
+  // could throw Error
+  const decodedAddr = coder.encode(
+    // may throw HexToBytesErrorType
+    hexToBytes(decodedData),
+  )
+
+  if (!decodedAddr) return null
+
+  return {
+    coinType: coder.coinType,
+    symbol: coder.name,
+    value: decodedAddr,
+  } as DecodeAddressResultFromPrimitiveTypesReturnType<coin>
+}
+
+// ================================
+// Decode address result
+// ================================
+
+export type DecodeAddressResultParameters<
+  coin extends number | string | undefined = undefined,
+> = {
+  /** Coin to get the address record for, can be either symbol (string) or coinId (number) (default: `60`) */
+  coin?: coin
+  /** Whether or not to throw decoding errors */
+  strict?: boolean
+}
+
+export type DecodeAddressResultReturnType<
+  coin extends number | string | undefined = undefined,
+> = DecodeAddressResultFromPrimitiveTypesReturnType<coin>
+
+export type DecodeAddressResultErrorType =
+  | GetCoderFromCoinErrorType
+  | DecodeFunctionResultErrorType
+  | ErrorType
+
+export function decodeAddressResult<
+  coin extends number | string | undefined = undefined,
+>(
+  data: Hex,
+  { coin = defaultCoinValue, strict }: DecodeAddressResultParameters<coin>,
+): DecodeAddressResultReturnType<coin> {
+  if (data === '0x') return null
+
+  // may throw GetCoderFromCoinErrorType
+  const coder = getCoderFromCoin(coin)
+
+  try {
+    const decodedData =
+      coder.coinType === 60
+        ? // may throw DecodeFunctionResultErrorType
+          decodeFunctionResult({
+            abi: publicResolverSingleAddrSnippet,
+            functionName: 'addr',
+            data,
+          })
+        : // may throw DecodeFunctionResultErrorType
+          decodeFunctionResult({
+            abi: publicResolverMultiAddrSnippet,
+            functionName: 'addr',
+            data,
+          })
+
+    return decodeAddressResultFromPrimitiveTypes({
+      decodedData,
+      coin: coin as coin,
+    })
+  } catch (error) {
+    if (strict) throw error
+    return null
+  }
+}

package/src/utils/coders/getContentHash.ts

@@ -0,0 +1,81 @@
+import {
+  type DecodeFunctionResultErrorType,
+  decodeFunctionResult,
+  type Hex,
+  type NamehashErrorType,
+  namehash,
+} from 'viem'
+import { publicResolverContenthashSnippet } from '../../contracts/publicResolver.js'
+import type { Prettify } from '../../types/index.js'
+import type {
+  DecodeContentHashErrorType,
+  DecodedContentHash,
+} from '../contentHash.js'
+import { decodeContentHash } from '../contentHash.js'
+
+// ================================
+// Get content hash parameters
+// ================================
+
+export type GetContentHashParameters = {
+  /** Name to get content hash record for */
+  name: string
+  /** Whether or not to throw decoding errors */
+  strict?: boolean
+}
+
+export type GetContentHashReturnType = Prettify<DecodedContentHash | null>
+
+export type GetContentHashErrorType = NamehashErrorType
+
+export function getContentHashParameters({
+  name,
+}: Omit<GetContentHashParameters, 'strict'>) {
+  return {
+    abi: publicResolverContenthashSnippet,
+    functionName: 'contenthash',
+    args: [namehash(name)],
+  } as const
+}
+
+// ================================
+// Decode content hash result from primitive types
+// ================================
+export type DecodeContentHashResultFromPrimitiveTypesErrorType =
+  DecodeContentHashErrorType
+
+export function decodeContentHashResultFromPrimitiveTypes({
+  decodedData,
+}: {
+  decodedData: Hex
+}): GetContentHashReturnType {
+  return decodeContentHash(decodedData)
+}
+
+// ================================
+// Decode content hash result
+// ================================
+
+export type DecodeContentHashResultErrorType =
+  | DecodeFunctionResultErrorType
+  | DecodeContentHashResultFromPrimitiveTypesErrorType
+
+export function decodeContentHashResult(
+  data: Hex,
+  { strict }: Pick<GetContentHashParameters, 'strict'>,
+): GetContentHashReturnType {
+  if (data === '0x') return null
+
+  try {
+    const decodedData = decodeFunctionResult({
+      abi: publicResolverContenthashSnippet,
+      functionName: 'contenthash',
+      data,
+    })
+
+    return decodeContentHashResultFromPrimitiveTypes({ decodedData })
+  } catch (error) {
+    if (strict) throw error
+    return null
+  }
+}

package/src/utils/coders/getText.ts

@@ -0,0 +1,104 @@
+import {
+  type DecodeFunctionResultErrorType,
+  decodeFunctionResult,
+  type Hex,
+  type NamehashErrorType,
+  namehash,
+} from 'viem'
+import { publicResolverTextSnippet } from '../../contracts/publicResolver.js'
+
+/** @deprecated */
+export type GetTextParameters = {
+  /** Name to get text record for */
+  name: string
+  /** Text record key to get */
+  key: string
+  /** Whether or not to throw decoding errors */
+  strict?: boolean
+}
+
+/** @deprecated */
+export type GetTextReturnType = string | null
+
+/** @deprecated */
+export type GetTextErrorType = Error
+
+// ================================
+// Get text parameters
+// ================================
+
+export type GetTextParametersParameters = {
+  /** Name to get text record for */
+  name: string
+  /** Text record key to get */
+  key: string
+}
+
+export type GetTextParametersReturnType = {
+  abi: typeof publicResolverTextSnippet
+  functionName: 'text'
+  args: readonly [Hex, string]
+}
+
+export type GetTextParametersErrorType = NamehashErrorType
+
+export function getTextParameters({ name, key }: GetTextParametersParameters) {
+  return {
+    abi: publicResolverTextSnippet,
+    functionName: 'text',
+    args: [namehash(name), key],
+  } as const
+}
+
+// ================================
+// Decode text result from primitive types
+// ================================
+
+export type DecodeTextResultFromPrimitiveTypesErrorType = never
+
+export function decodeTextResultFromPrimitiveTypes({
+  decodedData,
+}: {
+  decodedData: string
+}): string | null {
+  if (decodedData === '') return null
+  return decodedData
+}
+
+// ================================
+// Decode text result
+// ================================
+
+export type DecodeTextResultParameters = {
+  strict?: boolean
+}
+
+export type DecodeTextResultReturnType = string | null
+
+export type DecodeTextResultErrorType =
+  | DecodeFunctionResultErrorType
+  | DecodeTextResultFromPrimitiveTypesErrorType
+
+export function decodeTextResult(
+  data: Hex,
+  {
+    strict,
+  }: {
+    strict?: boolean
+  },
+): DecodeTextResultReturnType {
+  if (data === '0x') return null
+
+  try {
+    const decodedData = decodeFunctionResult({
+      abi: publicResolverTextSnippet,
+      functionName: 'text',
+      data,
+    })
+
+    return decodeTextResultFromPrimitiveTypes({ decodedData })
+  } catch (error) {
+    if (strict) throw error
+    return null
+  }
+}