@ensdomains/ensjs 4.1.2 → 5.0.0-alpha.1

package/src/functions/public/_getAddr.ts

@@ -1,121 +0,0 @@
-import {
-  type Hex,
-  decodeFunctionResult,
-  encodeFunctionData,
-  hexToBytes,
-  trim,
-} from 'viem'
-import { namehash } from '../../utils/normalise.js'
-
-import type { ClientWithEns } from '../../contracts/consts.js'
-import {
-  publicResolverMultiAddrSnippet,
-  publicResolverSingleAddrSnippet,
-} from '../../contracts/publicResolver.js'
-import type {
-  DecodedAddr,
-  Prettify,
-  SimpleTransactionRequest,
-} from '../../types.js'
-import { EMPTY_ADDRESS } from '../../utils/consts.js'
-import { generateFunction } from '../../utils/generateFunction.js'
-import { getCoderFromCoin } from '../../utils/normaliseCoinId.js'
-
-export type InternalGetAddrParameters = {
-  /** 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?: string | number
-  /** Optionally return raw bytes value of address record (default: false) */
-  bypassFormat?: boolean
-  /** Whether or not to throw decoding errors */
-  strict?: boolean
-}
-
-export type InternalGetAddrReturnType = Prettify<DecodedAddr | null>
-
-const encode = (
-  _client: ClientWithEns,
-  { name, coin = 60, bypassFormat }: Omit<InternalGetAddrParameters, 'strict'>,
-): SimpleTransactionRequest => {
-  const coder = getCoderFromCoin(coin)
-  if (coder.coinType === 60) {
-    return {
-      to: EMPTY_ADDRESS,
-      data: encodeFunctionData({
-        abi: publicResolverSingleAddrSnippet,
-        functionName: 'addr',
-        args: [namehash(name)],
-      }),
-    }
-  }
-
-  if (bypassFormat) {
-    return {
-      to: EMPTY_ADDRESS,
-      data: encodeFunctionData({
-        abi: publicResolverMultiAddrSnippet,
-        functionName: 'addr',
-        args: [namehash(name), BigInt(coin)],
-      }),
-    }
-  }
-
-  return {
-    to: EMPTY_ADDRESS,
-    data: encodeFunctionData({
-      abi: publicResolverMultiAddrSnippet,
-      functionName: 'addr',
-      args: [namehash(name), BigInt(coder.coinType)],
-    }),
-  }
-}
-
-const decode = async (
-  _client: ClientWithEns,
-  data: Hex,
-  { coin = 60, strict }: Pick<InternalGetAddrParameters, 'coin' | 'strict'>,
-): Promise<InternalGetAddrReturnType> => {
-  if (data === '0x') return null
-
-  const coder = getCoderFromCoin(coin)
-  let response: Hex
-
-  try {
-    if (coder.coinType === 60) {
-      response = decodeFunctionResult({
-        abi: publicResolverSingleAddrSnippet,
-        functionName: 'addr',
-        data,
-      })
-    } else {
-      response = decodeFunctionResult({
-        abi: publicResolverMultiAddrSnippet,
-        functionName: 'addr',
-        data,
-      })
-    }
-
-    if (!response) return null
-
-    const trimmed = trim(response)
-    if (trimmed === '0x' || trimmed === '0x0' || trimmed === '0x00') {
-      return null
-    }
-
-    const decodedAddr = coder.encode(hexToBytes(response))
-
-    if (!decodedAddr) {
-      return null
-    }
-
-    return { id: coder.coinType, name: coder.name, value: decodedAddr }
-  } catch (error) {
-    if (strict) throw error
-    return null
-  }
-}
-
-const _getAddr = generateFunction({ encode, decode })
-
-export default _getAddr

package/src/functions/public/_getContentHash.ts

@@ -1,60 +0,0 @@
-import { type Hex, decodeFunctionResult, encodeFunctionData } from 'viem'
-import type { ClientWithEns } from '../../contracts/consts.js'
-import { publicResolverContenthashSnippet } from '../../contracts/publicResolver.js'
-import type { Prettify, SimpleTransactionRequest } from '../../types.js'
-import { EMPTY_ADDRESS } from '../../utils/consts.js'
-import {
-  type DecodedContentHash,
-  decodeContentHash,
-} from '../../utils/contentHash.js'
-import { generateFunction } from '../../utils/generateFunction.js'
-import { namehash } from '../../utils/normalise.js'
-
-export type InternalGetContentHashParameters = {
-  /** Name to get content hash record for */
-  name: string
-  /** Whether or not to throw decoding errors */
-  strict?: boolean
-}
-
-export type InternalGetContentHashReturnType =
-  Prettify<DecodedContentHash | null>
-
-const encode = (
-  _client: ClientWithEns,
-  { name }: Omit<InternalGetContentHashParameters, 'strict'>,
-): SimpleTransactionRequest => {
-  return {
-    to: EMPTY_ADDRESS,
-    data: encodeFunctionData({
-      abi: publicResolverContenthashSnippet,
-      functionName: 'contenthash',
-      args: [namehash(name)],
-    }),
-  }
-}
-
-const decode = async (
-  _client: ClientWithEns,
-  data: Hex,
-  { strict }: Pick<InternalGetContentHashParameters, 'strict'>,
-): Promise<InternalGetContentHashReturnType> => {
-  if (data === '0x') return null
-
-  try {
-    const response = decodeFunctionResult({
-      abi: publicResolverContenthashSnippet,
-      functionName: 'contenthash',
-      data,
-    })
-
-    return decodeContentHash(response)
-  } catch (error) {
-    if (strict) throw error
-    return null
-  }
-}
-
-const _getContentHash = generateFunction({ encode, decode })
-
-export default _getContentHash

package/src/functions/public/_getText.ts

@@ -1,59 +0,0 @@
-import { type Hex, decodeFunctionResult, encodeFunctionData } from 'viem'
-import type { ClientWithEns } from '../../contracts/consts.js'
-import { publicResolverTextSnippet } from '../../contracts/publicResolver.js'
-import type { SimpleTransactionRequest } from '../../types.js'
-import { EMPTY_ADDRESS } from '../../utils/consts.js'
-import { generateFunction } from '../../utils/generateFunction.js'
-import { namehash } from '../../utils/normalise.js'
-
-export type InternalGetTextParameters = {
-  /** Name to get text record for */
-  name: string
-  /** Text record key to get */
-  key: string
-  /** Whether or not to throw decoding errors */
-  strict?: boolean
-}
-
-export type InternalGetTextReturnType = string | null
-
-const encode = (
-  _client: ClientWithEns,
-  { name, key }: Omit<InternalGetTextParameters, 'strict'>,
-): SimpleTransactionRequest => {
-  return {
-    to: EMPTY_ADDRESS,
-    data: encodeFunctionData({
-      abi: publicResolverTextSnippet,
-      functionName: 'text',
-      args: [namehash(name), key],
-    }),
-  }
-}
-
-const decode = async (
-  _client: ClientWithEns,
-  data: Hex,
-  { strict }: Pick<InternalGetTextParameters, 'strict'>,
-): Promise<InternalGetTextReturnType> => {
-  if (data === '0x') return null
-
-  try {
-    const response = decodeFunctionResult({
-      abi: publicResolverTextSnippet,
-      functionName: 'text',
-      data,
-    })
-
-    if (!response) return null
-
-    return response
-  } catch (error) {
-    if (strict) throw error
-    return null
-  }
-}
-
-const _getText = generateFunction({ encode, decode })
-
-export default _getText

package/src/functions/public/batch.ts

@@ -1,101 +0,0 @@
-import type { Hex } from 'viem'
-import type { ClientWithEns } from '../../contracts/consts.js'
-import { FunctionNotBatchableError } from '../../errors/public.js'
-import type {
-  SimpleTransactionRequest,
-  TransactionRequestWithPassthrough,
-} from '../../types.js'
-import {
-  type BatchFunctionResult,
-  type GeneratedFunction,
-  generateFunction,
-} from '../../utils/generateFunction.js'
-import multicallWrapper from './multicallWrapper.js'
-
-type ExtractResult<TFunction extends BatchFunctionResult> = TFunction extends {
-  decode: (...args: any[]) => Promise<infer U>
-}
-  ? U
-  : never
-
-export type BatchParameters = BatchFunctionResult[]
-
-export type BatchReturnType<TFunctions extends BatchFunctionResult[]> = {
-  [TFunctionName in keyof TFunctions]: ExtractResult<TFunctions[TFunctionName]>
-}
-
-const encode = (
-  client: ClientWithEns,
-  ...items: BatchFunctionResult[]
-): TransactionRequestWithPassthrough => {
-  const rawDataArr: SimpleTransactionRequest[] = items.map(
-    ({ args, encode: encodeRef }, i: number) => {
-      if (!encodeRef) throw new FunctionNotBatchableError({ functionIndex: i })
-      return encodeRef(client, ...args)
-    },
-  )
-  const response = multicallWrapper.encode(client, {
-    transactions: rawDataArr,
-  })
-  return { ...response, passthrough: rawDataArr }
-}
-
-const decode = async <I extends BatchFunctionResult[]>(
-  client: ClientWithEns,
-  data: Hex,
-  passthrough: TransactionRequestWithPassthrough[],
-  ...items: I
-): Promise<BatchReturnType<I>> => {
-  const response = await multicallWrapper.decode(client, data, passthrough)
-  if (!response) throw new Error('No response from multicall')
-
-  return Promise.all(
-    response.map((ret, i: number) => {
-      if (passthrough[i].passthrough) {
-        return items[i].decode(
-          client,
-          ret.returnData,
-          passthrough[i].passthrough,
-          ...items[i].args,
-        )
-      }
-      return items[i].decode(client, ret.returnData, ...items[i].args)
-    }),
-  ) as Promise<BatchReturnType<I>>
-}
-
-type BatchableFunctionObject = GeneratedFunction<typeof encode, typeof decode>
-
-/**
- * Batches multiple read functions into a single call.
- * @param client - {@link ClientWithEns}
- * @param ...parameters - Array of {@link BatchFunctionResult} objects
- * @returns Array of return values from each function
- *
- * @example
- * import { createPublicClient, http } from 'viem'
- * import { mainnet } from 'viem/chains'
- * import { addEnsContracts } from '@ensdomains/ensjs'
- * import { batch, getTextRecord, getAddressRecord } from '@ensdomains/ensjs/public'
- *
- * const client = createPublicClient({
- *   chain: addEnsContracts(mainnet),
- *   transport: http(),
- * })
- * const result = await batch(
- *   client,
- *   getTextRecord.batch({ name: 'ens.eth', key: 'com.twitter' }),
- *   getAddressRecord.batch({ name: 'ens.eth', coin: 'ETH' }),
- * )
- * // ['ensdomains', { id: 60, name: 'ETH', value: '0xFe89cc7aBB2C4183683ab71653C4cdc9B02D44b7 }]
- */
-const batch = generateFunction({
-  encode,
-  decode,
-}) as (<I extends BatchFunctionResult[]>(
-  client: ClientWithEns,
-  ...args: I
-) => Promise<BatchReturnType<I>>) &
-  BatchableFunctionObject
-
-export default batch

package/src/functions/public/getAbiRecord.ts

@@ -1,87 +0,0 @@
-import type { BaseError, Hex } from 'viem'
-import type { ClientWithEns } from '../../contracts/consts.js'
-import type {
-  GenericPassthrough,
-  Prettify,
-  SimpleTransactionRequest,
-} from '../../types.js'
-import {
-  type GeneratedFunction,
-  generateFunction,
-} from '../../utils/generateFunction.js'
-import _getAbi, {
-  type InternalGetAbiParameters,
-  type InternalGetAbiReturnType,
-} from './_getAbi.js'
-import universalWrapper from './universalWrapper.js'
-
-export type GetAbiRecordParameters = Prettify<
-  InternalGetAbiParameters & {
-    /** Batch gateway URLs to use for resolving CCIP-read requests. */
-    gatewayUrls?: string[]
-  }
->
-
-export type GetAbiRecordReturnType = Prettify<InternalGetAbiReturnType>
-
-const encode = (
-  client: ClientWithEns,
-  {
-    name,
-    supportedContentTypes,
-    gatewayUrls,
-  }: Omit<GetAbiRecordParameters, 'strict'>,
-): SimpleTransactionRequest => {
-  const prData = _getAbi.encode(client, { name, supportedContentTypes })
-  return universalWrapper.encode(client, {
-    name,
-    data: prData.data,
-    gatewayUrls,
-  })
-}
-
-const decode = async (
-  client: ClientWithEns,
-  data: Hex | BaseError,
-  passthrough: GenericPassthrough,
-  {
-    strict,
-    gatewayUrls,
-  }: Pick<GetAbiRecordParameters, 'strict' | 'gatewayUrls'>,
-): Promise<GetAbiRecordReturnType> => {
-  const urData = await universalWrapper.decode(client, data, passthrough, {
-    strict,
-    gatewayUrls,
-  })
-  if (!urData) return null
-  return _getAbi.decode(client, urData.data, { strict })
-}
-
-type BatchableFunctionObject = GeneratedFunction<typeof encode, typeof decode>
-
-/**
- * Gets the ABI record for a name
- * @param client - {@link ClientWithEns}
- * @param parameters - {@link GetAbiRecordParameters}
- * @returns ABI record for the name, or `null` if not found. {@link GetAbiRecordReturnType}
- *
- * @example
- * import { createPublicClient, http } from 'viem'
- * import { mainnet } from 'viem/chains'
- * import { addEnsContracts } from '@ensdomains/ensjs'
- * import { getAbiRecord } from '@ensdomains/ensjs/public'
- *
- * const client = createPublicClient({
- *   chain: addEnsContracts(mainnet),
- *   transport: http(),
- * })
- * const result = await getAbiRecord(client, { name: 'ens.eth' })
- * // TODO: real example
- */
-const getAbiRecord = generateFunction({ encode, decode }) as ((
-  client: ClientWithEns,
-  { name, strict, gatewayUrls, supportedContentTypes }: GetAbiRecordParameters,
-) => Promise<GetAbiRecordReturnType>) &
-  BatchableFunctionObject
-
-export default getAbiRecord

package/src/functions/public/getAddressRecord.ts

@@ -1,88 +0,0 @@
-import type { BaseError, Hex } from 'viem'
-import type { ClientWithEns } from '../../contracts/consts.js'
-import type {
-  GenericPassthrough,
-  Prettify,
-  SimpleTransactionRequest,
-} from '../../types.js'
-import {
-  type GeneratedFunction,
-  generateFunction,
-} from '../../utils/generateFunction.js'
-import _getAddr, {
-  type InternalGetAddrParameters,
-  type InternalGetAddrReturnType,
-} from './_getAddr.js'
-import universalWrapper from './universalWrapper.js'
-
-export type GetAddressRecordParameters = Prettify<
-  InternalGetAddrParameters & {
-    /** Batch gateway URLs to use for resolving CCIP-read requests. */
-    gatewayUrls?: string[]
-  }
->
-
-export type GetAddressRecordReturnType = Prettify<InternalGetAddrReturnType>
-
-const encode = (
-  client: ClientWithEns,
-  {
-    name,
-    coin,
-    gatewayUrls,
-  }: Omit<GetAddressRecordParameters, 'strict' | 'bypassFormat'>,
-): SimpleTransactionRequest => {
-  const prData = _getAddr.encode(client, { name, coin })
-  return universalWrapper.encode(client, {
-    name,
-    data: prData.data,
-    gatewayUrls,
-  })
-}
-
-const decode = async (
-  client: ClientWithEns,
-  data: Hex | BaseError,
-  passthrough: GenericPassthrough,
-  {
-    coin,
-    strict,
-    gatewayUrls,
-  }: Pick<GetAddressRecordParameters, 'coin' | 'strict' | 'gatewayUrls'>,
-): Promise<GetAddressRecordReturnType> => {
-  const urData = await universalWrapper.decode(client, data, passthrough, {
-    strict,
-    gatewayUrls,
-  })
-  if (!urData) return null
-  return _getAddr.decode(client, urData.data, { coin, strict })
-}
-
-type BatchableFunctionObject = GeneratedFunction<typeof encode, typeof decode>
-
-/**
- * Gets an address record for a name and specified coin
- * @param client - {@link ClientWithEns}
- * @param parameters - {@link GetAddressRecordParameters}
- * @returns Coin value object, or `null` if not found. {@link GetAddressRecordReturnType}
- *
- * @example
- * import { createPublicClient, http } from 'viem'
- * import { mainnet } from 'viem/chains'
- * import { addEnsContracts } from '@ensdomains/ensjs'
- * import { getAddressRecord } from '@ensdomains/ensjs/public'
- *
- * const client = createPublicClient({
- *   chain: addEnsContracts(mainnet),
- *   transport: http(),
- * })
- * const result = await getAddressRecord(client, { name: 'ens.eth', coin: 'ETH' })
- * // { id: 60, name: 'ETH , value: '0xFe89cc7aBB2C4183683ab71653C4cdc9B02D44b7' }
- */
-const getAddressRecord = generateFunction({ encode, decode }) as ((
-  client: ClientWithEns,
-  { name, coin, bypassFormat, strict, gatewayUrls }: GetAddressRecordParameters,
-) => Promise<GetAddressRecordReturnType>) &
-  BatchableFunctionObject
-
-export default getAddressRecord

package/src/functions/public/getAvailable.ts

@@ -1,92 +0,0 @@
-import {
-  type BaseError,
-  type Hex,
-  decodeFunctionResult,
-  encodeFunctionData,
-  labelhash,
-} from 'viem'
-import { baseRegistrarAvailableSnippet } from '../../contracts/baseRegistrar.js'
-import type { ClientWithEns } from '../../contracts/consts.js'
-import { getChainContractAddress } from '../../contracts/getChainContractAddress.js'
-import { UnsupportedNameTypeError } from '../../errors/general.js'
-import type { SimpleTransactionRequest } from '../../types.js'
-import {
-  type GeneratedFunction,
-  generateFunction,
-} from '../../utils/generateFunction.js'
-import { getNameType } from '../../utils/getNameType.js'
-
-export type GetAvailableParameters = {
-  /** Name to check availability for, only compatible for eth 2ld */
-  name: string
-}
-
-export type GetAvailableReturnType = boolean
-
-const encode = (
-  client: ClientWithEns,
-  { name }: GetAvailableParameters,
-): SimpleTransactionRequest => {
-  const labels = name.split('.')
-  const nameType = getNameType(name)
-  if (nameType !== 'eth-2ld')
-    throw new UnsupportedNameTypeError({
-      nameType,
-      supportedNameTypes: ['eth-2ld'],
-      details: 'Currently only eth-2ld names can be checked for availability',
-    })
-
-  return {
-    to: getChainContractAddress({
-      client,
-      contract: 'ensBaseRegistrarImplementation',
-    }),
-    data: encodeFunctionData({
-      abi: baseRegistrarAvailableSnippet,
-      functionName: 'available',
-      args: [BigInt(labelhash(labels[0]))],
-    }),
-  }
-}
-
-const decode = async (
-  _client: ClientWithEns,
-  data: Hex | BaseError,
-): Promise<GetAvailableReturnType> => {
-  if (typeof data === 'object') throw data
-  const result = decodeFunctionResult({
-    abi: baseRegistrarAvailableSnippet,
-    functionName: 'available',
-    data,
-  })
-  return result
-}
-
-type BatchableFunctionObject = GeneratedFunction<typeof encode, typeof decode>
-
-/**
- * Gets the availability of a name to register
- * @param client - {@link ClientWithEns}
- * @param parameters - {@link GetAvailableParameters}
- * @returns Availability as boolean. {@link GetAvailableReturnType}
- *
- * @example
- * import { createPublicClient, http } from 'viem'
- * import { mainnet } from 'viem/chains'
- * import { addEnsContracts } from '@ensdomains/ensjs'
- * import { getAvailable } from '@ensdomains/ensjs/public'
- *
- * const client = createPublicClient({
- *   chain: addEnsContracts(mainnet),
- *   transport: http(),
- * })
- * const result = await getAvailable(client, { name: 'ens.eth' })
- * // false
- */
-const getAvailable = generateFunction({ encode, decode }) as ((
-  client: ClientWithEns,
-  { name }: GetAvailableParameters,
-) => Promise<GetAvailableReturnType>) &
-  BatchableFunctionObject
-
-export default getAvailable

package/src/functions/public/getContentHashRecord.ts

@@ -1,84 +0,0 @@
-import type { BaseError, Hex } from 'viem'
-import type { ClientWithEns } from '../../contracts/consts.js'
-import type {
-  GenericPassthrough,
-  Prettify,
-  TransactionRequestWithPassthrough,
-} from '../../types.js'
-import {
-  type GeneratedFunction,
-  generateFunction,
-} from '../../utils/generateFunction.js'
-import _getContentHash, {
-  type InternalGetContentHashParameters,
-  type InternalGetContentHashReturnType,
-} from './_getContentHash.js'
-import universalWrapper from './universalWrapper.js'
-
-export type GetContentHashRecordParameters = Prettify<
-  InternalGetContentHashParameters & {
-    /** Batch gateway URLs to use for resolving CCIP-read requests. */
-    gatewayUrls?: string[]
-  }
->
-
-export type GetContentHashRecordReturnType =
-  Prettify<InternalGetContentHashReturnType>
-
-const encode = (
-  client: ClientWithEns,
-  { name, gatewayUrls }: Omit<GetContentHashRecordParameters, 'strict'>,
-): TransactionRequestWithPassthrough => {
-  const prData = _getContentHash.encode(client, { name })
-  return universalWrapper.encode(client, {
-    name,
-    data: prData.data,
-    gatewayUrls,
-  })
-}
-
-const decode = async (
-  client: ClientWithEns,
-  data: Hex | BaseError,
-  passthrough: GenericPassthrough,
-  {
-    strict,
-    gatewayUrls,
-  }: Pick<GetContentHashRecordParameters, 'strict' | 'gatewayUrls'>,
-): Promise<GetContentHashRecordReturnType> => {
-  const urData = await universalWrapper.decode(client, data, passthrough, {
-    strict,
-    gatewayUrls,
-  })
-  if (!urData) return null
-  return _getContentHash.decode(client, urData.data, { strict })
-}
-
-type BatchableFunctionObject = GeneratedFunction<typeof encode, typeof decode>
-
-/**
- * Gets the content hash record for a name
- * @param client - {@link ClientWithEns}
- * @param parameters - {@link GetContentHashRecordParameters}
- * @returns Content hash object, or `null` if not found. {@link GetContentHashRecordReturnType}
- *
- * @example
- * import { createPublicClient, http } from 'viem'
- * import { mainnet } from 'viem/chains'
- * import { addEnsContracts } from '@ensdomains/ensjs'
- * import { getContentHashRecord } from '@ensdomains/ensjs/public'
- *
- * const client = createPublicClient({
- *   chain: addEnsContracts(mainnet),
- *   transport: http(),
- * })
- * const result = await getContentHashRecord(client, { name: 'ens.eth' })
- * // { protocolType: 'ipfs', decoded: 'k51qzi5uqu5djdczd6zw0grmo23j2vkj9uzvujencg15s5rlkq0ss4ivll8wqw' }
- */
-const getContentHashRecord = generateFunction({ encode, decode }) as ((
-  client: ClientWithEns,
-  { name, strict, gatewayUrls }: GetContentHashRecordParameters,
-) => Promise<GetContentHashRecordReturnType>) &
-  BatchableFunctionObject
-
-export default getContentHashRecord