@ensdomains/ensjs 4.1.2 → 5.0.0-alpha.1

package/src/functions/public/getResolver.ts

@@ -1,101 +0,0 @@
-import {
-  type Address,
-  type BaseError,
-  type Hex,
-  decodeFunctionResult,
-  encodeFunctionData,
-  getContractError,
-  toHex,
-} from 'viem'
-import type { ClientWithEns } from '../../contracts/consts.js'
-import { getChainContractAddress } from '../../contracts/getChainContractAddress.js'
-import { universalResolverFindResolverSnippet } from '../../contracts/universalResolver.js'
-import type {
-  GenericPassthrough,
-  TransactionRequestWithPassthrough,
-} from '../../types.js'
-import { EMPTY_ADDRESS } from '../../utils/consts.js'
-import {
-  type GeneratedFunction,
-  generateFunction,
-} from '../../utils/generateFunction.js'
-import { packetToBytes } from '../../utils/hexEncodedName.js'
-
-export type GetResolverParameters = {
-  /** Name to get resolver for */
-  name: string
-}
-
-export type GetResolverReturnType = Address | null
-
-const encode = (
-  client: ClientWithEns,
-  { name }: GetResolverParameters,
-): TransactionRequestWithPassthrough => {
-  const address = getChainContractAddress({
-    client,
-    contract: 'ensUniversalResolver',
-  })
-  const args = [toHex(packetToBytes(name))] as const
-  return {
-    to: address,
-    data: encodeFunctionData({
-      abi: universalResolverFindResolverSnippet,
-      functionName: 'findResolver',
-      args,
-    }),
-    passthrough: { address, args },
-  }
-}
-
-const decode = async (
-  _client: ClientWithEns,
-  data: Hex | BaseError,
-  passthrough: GenericPassthrough,
-): Promise<GetResolverReturnType> => {
-  if (typeof data === 'object')
-    throw getContractError(data, {
-      abi: universalResolverFindResolverSnippet,
-      functionName: 'findResolver',
-      args: passthrough.args,
-      address: passthrough.address,
-    }) as BaseError
-  const response = decodeFunctionResult({
-    abi: universalResolverFindResolverSnippet,
-    functionName: 'findResolver',
-    data,
-  })
-
-  if (response[0] === EMPTY_ADDRESS) return null
-
-  return response[0]
-}
-
-type BatchableFunctionObject = GeneratedFunction<typeof encode, typeof decode>
-
-/**
- * Gets the resolver address for a name.
- * @param client - {@link ClientWithEns}
- * @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
- */
-const getResolver = generateFunction({ encode, decode }) as ((
-  client: ClientWithEns,
-  { name }: GetResolverParameters,
-) => Promise<GetResolverReturnType>) &
-  BatchableFunctionObject
-
-export default getResolver

package/src/functions/public/getSupportedInterfaces.ts

@@ -1,114 +0,0 @@
-import {
-  type Address,
-  type BaseError,
-  type Hex,
-  encodeFunctionData,
-  padHex,
-} 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>
-  }
-}
-
-/**
- * Gets the supported interfaces for any contract address.
- * @param client - {@link ClientWithEns}
- * @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]
- */
-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

@@ -1,83 +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 _getText, {
-  type InternalGetTextParameters,
-  type InternalGetTextReturnType,
-} from './_getText.js'
-import universalWrapper from './universalWrapper.js'
-
-export type GetTextRecordParameters = Prettify<
-  InternalGetTextParameters & {
-    /** Batch gateway URLs to use for resolving CCIP-read requests. */
-    gatewayUrls?: string[]
-  }
->
-
-export type GetTextRecordReturnType = Prettify<InternalGetTextReturnType>
-
-const encode = (
-  client: ClientWithEns,
-  { name, key, gatewayUrls }: Omit<GetTextRecordParameters, 'strict'>,
-): SimpleTransactionRequest => {
-  const prData = _getText.encode(client, { name, key })
-  return universalWrapper.encode(client, {
-    name,
-    data: prData.data,
-    gatewayUrls,
-  })
-}
-
-const decode = async (
-  client: ClientWithEns,
-  data: Hex | BaseError,
-  passthrough: GenericPassthrough,
-  {
-    strict,
-    gatewayUrls,
-  }: Pick<GetTextRecordParameters, 'strict' | 'gatewayUrls'>,
-): Promise<GetTextRecordReturnType> => {
-  const urData = await universalWrapper.decode(client, data, passthrough, {
-    strict,
-    gatewayUrls,
-  })
-  if (!urData) return null
-  return _getText.decode(client, urData.data, { strict })
-}
-
-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 } 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
- */
-const getTextRecord = generateFunction({ encode, decode }) as ((
-  client: ClientWithEns,
-  { name, key, strict, gatewayUrls }: GetTextRecordParameters,
-) => Promise<GetTextRecordReturnType>) &
-  BatchableFunctionObject
-
-export default getTextRecord

package/src/functions/public/getWrapperData.ts

@@ -1,129 +0,0 @@
-import {
-  type Address,
-  type BaseError,
-  type Hex,
-  decodeFunctionResult,
-  encodeFunctionData,
-  getContractError,
-} 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 { type DecodedFuses, decodeFuses } from '../../utils/fuses.js'
-import {
-  type GeneratedFunction,
-  generateFunction,
-} 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,
-    }) as BaseError
-  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 } 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' })
- */
-const getWrapperData = generateFunction({ encode, decode }) as ((
-  client: ClientWithEns,
-  { name }: GetWrapperDataParameters,
-) => Promise<GetWrapperDataReturnType>) &
-  BatchableFunctionObject
-
-export default getWrapperData

package/src/functions/public/getWrapperName.ts

@@ -1,98 +0,0 @@
-import {
-  type BaseError,
-  type Hex,
-  decodeFunctionResult,
-  encodeFunctionData,
-  getContractError,
-  hexToBytes,
-} 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 {
-  type GeneratedFunction,
-  generateFunction,
-} 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,
-    }) as BaseError
-  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 } from '@ensdomains/ensjs'
- * import { getWrapperName } from '@ensdomains/ensjs/public'
- *
- * 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

@@ -1,88 +0,0 @@
-import {
-  type BaseError,
-  type Hex,
-  decodeFunctionResult,
-  encodeFunctionData,
-  getContractError,
-  offchainLookup,
-} 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: [],
-    }) as BaseError
-  }
-  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