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

package/src/functions/public/getPrice.ts

@@ -0,0 +1,147 @@
+import {
+  BaseError,
+  decodeFunctionResult,
+  encodeFunctionData,
+  type Hex,
+} from 'viem'
+import { bulkRenewalRentPriceSnippet } from '../../contracts/bulkRenewal.js'
+import type { ClientWithEns } from '../../contracts/consts.js'
+import { ethRegistrarControllerRentPriceSnippet } from '../../contracts/ethRegistrarController.js'
+import { getChainContractAddress } from '../../contracts/getChainContractAddress.js'
+import { UnsupportedNameTypeError } from '../../errors/general.js'
+import type { SimpleTransactionRequest } from '../../types.js'
+import {
+  generateFunction,
+  type GeneratedFunction,
+} from '../../utils/generateFunction.js'
+import { getNameType } from '../../utils/getNameType.js'
+import multicallWrapper from './multicallWrapper.js'
+
+export type GetPriceParameters = {
+  /** Name, or array of names, to get price for */
+  nameOrNames: string | string[]
+  /** Duration in seconds to get price for */
+  duration: bigint | number
+}
+
+export type GetPriceReturnType = {
+  /** Price base value */
+  base: bigint
+  /** Price premium */
+  premium: bigint
+}
+
+const encode = (
+  client: ClientWithEns,
+  { nameOrNames, duration }: GetPriceParameters,
+): SimpleTransactionRequest => {
+  const names = (Array.isArray(nameOrNames) ? nameOrNames : [nameOrNames]).map(
+    (name) => {
+      const labels = name.split('.')
+      const nameType = getNameType(name)
+      if (nameType !== 'eth-2ld' && nameType !== 'tld')
+        throw new UnsupportedNameTypeError({
+          nameType,
+          supportedNameTypes: ['eth-2ld', 'tld'],
+          details: 'Currently only the price of eth-2ld names can be fetched',
+        })
+      return labels[0]
+    },
+  )
+
+  if (names.length > 1) {
+    const bulkRenewalAddress = getChainContractAddress({
+      client,
+      contract: 'ensBulkRenewal',
+    })
+    return multicallWrapper.encode(client, {
+      transactions: [
+        {
+          to: bulkRenewalAddress,
+          data: encodeFunctionData({
+            abi: bulkRenewalRentPriceSnippet,
+            functionName: 'rentPrice',
+            args: [names, BigInt(duration)],
+          }),
+        },
+        {
+          to: bulkRenewalAddress,
+          data: encodeFunctionData({
+            abi: bulkRenewalRentPriceSnippet,
+            functionName: 'rentPrice',
+            args: [names, 0n],
+          }),
+        },
+      ],
+    })
+  }
+  return {
+    to: getChainContractAddress({
+      client,
+      contract: 'ensEthRegistrarController',
+    }),
+    data: encodeFunctionData({
+      abi: ethRegistrarControllerRentPriceSnippet,
+      functionName: 'rentPrice',
+      args: [names[0], BigInt(duration)],
+    }),
+  }
+}
+
+const decode = async (
+  client: ClientWithEns,
+  data: Hex | BaseError,
+  { nameOrNames }: GetPriceParameters,
+): Promise<GetPriceReturnType> => {
+  if (typeof data === 'object') throw data
+  const isBulkRenewal = Array.isArray(nameOrNames) && nameOrNames.length > 1
+  if (isBulkRenewal) {
+    const result = await multicallWrapper.decode(client, data, [])
+    const price = decodeFunctionResult({
+      abi: bulkRenewalRentPriceSnippet,
+      functionName: 'rentPrice',
+      data: result[0].returnData,
+    })
+    const premium = decodeFunctionResult({
+      abi: bulkRenewalRentPriceSnippet,
+      functionName: 'rentPrice',
+      data: result[1].returnData,
+    })
+    const base = price - premium
+    return { base, premium }
+  }
+
+  return decodeFunctionResult({
+    abi: ethRegistrarControllerRentPriceSnippet,
+    functionName: 'rentPrice',
+    data,
+  })
+}
+
+type BatchableFunctionObject = GeneratedFunction<typeof encode, typeof decode>
+
+/**
+ * Gets the price of a name, or array of names, for a given duration.
+ * @param client - {@link ClientWithEns}
+ * @param parameters - {@link GetPriceParameters}
+ * @returns Price data object. {@link GetPriceReturnType}
+ *
+ * @example
+ * import { createPublicClient, http } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { addEnsContracts, getPrice } from '@ensdomains/ensjs'
+ *
+ * const client = createPublicClient({
+ *   chain: addEnsContracts(mainnet),
+ *   transport: http(),
+ * })
+ * const result = await getPrice(client, { nameOrNames: 'ens.eth' })
+ * // { base: 352828971668930335n, premium: 0n }
+ */
+const getPrice = generateFunction({ encode, decode }) as ((
+  client: ClientWithEns,
+  { nameOrNames, duration }: GetPriceParameters,
+) => Promise<GetPriceReturnType>) &
+  BatchableFunctionObject
+
+export default getPrice

package/src/functions/public/getRecords.ts

@@ -0,0 +1,384 @@
+import {
+  BaseError,
+  decodeAbiParameters,
+  decodeErrorResult,
+  decodeFunctionResult,
+  encodeFunctionData,
+  getContractError,
+  toHex,
+  type Address,
+  type Hex,
+} from 'viem'
+import type { ClientWithEns } from '../../contracts/consts.js'
+import { getChainContractAddress } from '../../contracts/getChainContractAddress.js'
+import { universalResolverResolveArraySnippet } from '../../contracts/universalResolver.js'
+import type {
+  DecodedAddr,
+  DecodedText,
+  SimpleTransactionRequest,
+  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 _getAbi, { type InternalGetAbiReturnType } from './_getAbi.js'
+import _getAddr from './_getAddr.js'
+import _getContentHash, {
+  type InternalGetContentHashReturnType,
+} from './_getContentHash.js'
+import _getText from './_getText.js'
+import multicallWrapper from './multicallWrapper.js'
+
+export type GetRecordsParameters = {
+  /** Name to get records for */
+  name: string
+  /** 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
+  }
+  /** Records to fetch */
+  records: {
+    /** Text record key array */
+    texts?: string[]
+    /** Coin record id/symbol array */
+    coins?: (string | number)[]
+    /** If true, will fetch content hash */
+    contentHash?: boolean
+    /** If true, will fetch ABI */
+    abi?: boolean
+  }
+}
+
+type WithContentHashResult = {
+  /** Retrieved content hash record for name */
+  contentHash: InternalGetContentHashReturnType
+}
+
+type WithAbiResult = {
+  /** Retrieved ABI record for name */
+  abi: InternalGetAbiReturnType
+}
+
+type WithTextsResult = {
+  /** Retrieved text records for name */
+  texts: DecodedText[]
+}
+
+type WithCoinsResult = {
+  /** Retrieved coins for name */
+  coins: DecodedAddr[]
+}
+
+type BaseGetRecordsReturnType = Partial<
+  WithContentHashResult & WithAbiResult & WithTextsResult & WithCoinsResult
+> & {
+  /** Resolver address used for fetch */
+  resolverAddress: Address
+}
+
+export type GetRecordsReturnType<
+  TParams extends GetRecordsParameters = GetRecordsParameters,
+> = TParams['records'] extends undefined
+  ? BaseGetRecordsReturnType
+  : (TParams['records']['contentHash'] extends true
+      ? WithContentHashResult
+      : {}) &
+      (TParams['records']['abi'] extends true ? WithAbiResult : {}) &
+      (TParams['records']['texts'] extends string[] ? WithTextsResult : {}) &
+      (TParams['records']['coins'] extends (string | number)[]
+        ? WithCoinsResult
+        : {}) & {
+        /** Resolver address used for fetch */
+        resolverAddress: Address
+      }
+
+type CallObj = {
+  key: string | number
+  call: SimpleTransactionRequest
+  type: 'coin' | 'text' | 'contentHash' | 'abi'
+}
+
+const encode = (
+  client: ClientWithEns,
+  { name, resolver, records }: GetRecordsParameters,
+): TransactionRequestWithPassthrough => {
+  const calls: (CallObj | null)[] = []
+  if (records.texts) {
+    for (const key of records.texts) {
+      calls.push({
+        key,
+        call: _getText.encode(client, { name, key }),
+        type: 'text',
+      })
+    }
+  }
+  if (records.coins) {
+    for (const coin of records.coins) {
+      calls.push({
+        key: coin,
+        call: _getAddr.encode(client, { name, coin }),
+        type: 'coin',
+      })
+    }
+  }
+  if (records.contentHash) {
+    calls.push({
+      key: 'contentHash',
+      call: _getContentHash.encode(client, { name }),
+      type: 'contentHash',
+    })
+  }
+  if (records.abi) {
+    calls.push({
+      key: 'abi',
+      call: _getAbi.encode(client, { name }),
+      type: 'abi',
+    })
+  }
+
+  const passthrough = calls
+
+  if (resolver?.address && !resolver.fallbackOnly) {
+    const encoded = multicallWrapper.encode(client, {
+      transactions: calls
+        .filter((c) => c)
+        .map((c) => ({ to: resolver.address, data: c!.call.data })),
+    })
+    return {
+      ...encoded,
+      passthrough,
+    }
+  }
+
+  const encoded = encodeFunctionData({
+    abi: universalResolverResolveArraySnippet,
+    functionName: 'resolve',
+    args: [
+      toHex(packetToBytes(name)),
+      calls.filter((c) => c).map((c) => c!.call.data),
+    ],
+  })
+
+  return {
+    to: getChainContractAddress({ client, contract: 'ensUniversalResolver' }),
+    data: encoded,
+    passthrough,
+  }
+}
+
+const decode = async <TParams extends GetRecordsParameters>(
+  client: ClientWithEns,
+  data: Hex | BaseError,
+  passthrough: (CallObj | null)[],
+  { name, resolver }: TParams,
+): Promise<GetRecordsReturnType<TParams>> => {
+  const calls = passthrough
+  let recordData: (Hex | null)[] = []
+  let resolverAddress: Address
+
+  if (resolver?.address && !resolver.fallbackOnly) {
+    const result = await multicallWrapper.decode(
+      client,
+      data,
+      passthrough.filter((c) => c).map((c) => c!.call),
+    )
+    resolverAddress = resolver.address
+    recordData = result.map((r) => r.returnData)
+  } else {
+    if (typeof data === 'object') {
+      const errorData = getRevertErrorData(data)
+      if (errorData) {
+        const decodedError = decodeErrorResult({
+          abi: universalResolverResolveArraySnippet,
+          data: errorData,
+        })
+        if (
+          decodedError.errorName === 'ResolverNotFound' ||
+          decodedError.errorName === 'ResolverWildcardNotSupported'
+        )
+          return passthrough.reduce(
+            (prev, curr) => {
+              if (!curr) return prev
+              if (curr.type === 'coin' && !('coin' in prev)) {
+                return { ...prev, coins: [] }
+              }
+              if (curr.type === 'text' && !('texts' in prev)) {
+                return { ...prev, texts: [] }
+              }
+              if (curr.type === 'contentHash' && !('contentHash' in prev)) {
+                return { ...prev, contentHash: null }
+              }
+              // abi
+              return { ...prev, abi: null }
+            },
+            {
+              resolverAddress: EMPTY_ADDRESS,
+            } as unknown as GetRecordsReturnType<TParams>,
+          )
+      }
+      throw getContractError(data, {
+        abi: universalResolverResolveArraySnippet,
+        functionName: 'resolve',
+        args: [
+          toHex(packetToBytes(name)),
+          calls.filter((c) => c).map((c) => c!.call.data),
+        ],
+        address: getChainContractAddress({
+          client,
+          contract: 'ensUniversalResolver',
+        }),
+      })
+    }
+    const result = decodeFunctionResult({
+      abi: universalResolverResolveArraySnippet,
+      functionName: 'resolve',
+      data,
+    })
+    ;[, resolverAddress] = result
+    recordData = [...result[0]]
+    for (let i = 0; i < recordData.length; i += 1) {
+      // error code for reverted call in batch
+      // this is expected when using offchain resolvers, so should be ignored
+      // Error((uint16, string)[])
+      // or if data is 0x, clear the call so there is no decoding errors
+      if (recordData[i]!.startsWith('0x0d1947a9') || recordData[i] === '0x') {
+        calls[i] = null
+        recordData[i] = null
+      }
+    }
+  }
+
+  const filteredCalls = calls.filter((x) => x) as CallObj[]
+  const filteredRecordData = recordData.filter((x) => x) as Hex[]
+
+  const returnedRecords: GetRecordsReturnType<GetRecordsParameters> =
+    await Promise.all(
+      filteredRecordData.map(async (item, i) => {
+        const { key, type } = filteredCalls[i]
+        const baseItem = { key, type }
+        if (type === 'contentHash') {
+          const decodedFromAbi = decodeAbiParameters(
+            [{ type: 'bytes' }] as const,
+            item,
+          )[0]
+          if (BigInt(decodedFromAbi) === 0n) {
+            return { ...baseItem, value: null }
+          }
+        }
+        if (type === 'text') {
+          const decodedFromAbi = await _getText.decode(client, item)
+          return { ...baseItem, value: decodedFromAbi }
+        }
+        if (type === 'coin') {
+          const decodedFromAbi = await _getAddr.decode(client, item, {
+            name,
+            coin: key,
+          })
+          return { ...baseItem, value: decodedFromAbi }
+        }
+        if (type === 'contentHash') {
+          const decodedFromAbi = await _getContentHash.decode(client, item)
+          return { ...baseItem, value: decodedFromAbi }
+        }
+        // abi
+        const decodedFromAbi = await _getAbi.decode(client, item)
+        return { ...baseItem, value: decodedFromAbi }
+      }),
+    ).then((results) =>
+      results.reduce(
+        (prev, curr) => {
+          if (curr.type === 'text' || curr.type === 'coin') {
+            if (!curr.value) {
+              return prev
+            }
+          }
+          if (curr.type === 'text') {
+            return {
+              ...prev,
+              texts: [
+                ...(prev.texts || []),
+                { key: curr.key, value: curr.value } as DecodedText,
+              ],
+            }
+          }
+          if (curr.type === 'coin') {
+            return {
+              ...prev,
+              coins: [...(prev.coins || []), curr.value as DecodedAddr],
+            }
+          }
+          if (curr.type === 'contentHash') {
+            return {
+              ...prev,
+              contentHash: curr.value as InternalGetContentHashReturnType,
+            }
+          }
+          // abi
+          return { ...prev, abi: curr.value as InternalGetAbiReturnType }
+        },
+        {
+          resolverAddress,
+        } as GetRecordsReturnType<
+          GetRecordsParameters & {
+            records: Required<GetRecordsParameters['records']>
+          }
+        >,
+      ),
+    )
+
+  return returnedRecords as GetRecordsReturnType<TParams>
+}
+
+type EncoderFunction = typeof encode
+type DecoderFunction = typeof decode<any>
+
+type BatchableFunctionObject = {
+  encode: EncoderFunction
+  decode: DecoderFunction
+  batch: <TParams extends GetRecordsParameters>(
+    args: TParams,
+  ) => {
+    args: [TParams]
+    encode: EncoderFunction
+    decode: typeof decode<TParams>
+  }
+}
+
+/**
+ * Gets arbitrary records for a name
+ * @param client - {@link ClientWithEns}
+ * @param parameters - {@link GetRecordsParameters}
+ * @returns Records data object. {@link GetRecordsReturnType}
+ *
+ * @example
+ * import { createPublicClient, http } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { addEnsContracts, getRecords } from '@ensdomains/ensjs'
+ *
+ * const client = createPublicClient({
+ *   chain: addEnsContracts(mainnet),
+ *   transport: http(),
+ * })
+ * const result = await getRecords(client, {
+ *   name: 'ens.eth',
+ *   records: {
+ *     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' } }
+ */
+const getRecords = generateFunction({ encode, decode }) as (<
+  TParams extends GetRecordsParameters,
+>(
+  client: ClientWithEns,
+  { name, records, resolver }: TParams,
+) => Promise<GetRecordsReturnType<TParams>>) &
+  BatchableFunctionObject
+
+export default getRecords

package/src/functions/public/getResolver.ts

@@ -0,0 +1,100 @@
+import {
+  BaseError,
+  decodeFunctionResult,
+  encodeFunctionData,
+  getContractError,
+  toHex,
+  type Address,
+  type Hex,
+} 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 {
+  generateFunction,
+  type GeneratedFunction,
+} 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,
+    })
+  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, getResolver } from '@ensdomains/ensjs'
+ *
+ * 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