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

package/src/functions/public/_getAbi.ts

@@ -0,0 +1,115 @@
+import {
+  decodeFunctionResult,
+  encodeFunctionData,
+  hexToBytes,
+  hexToString,
+  type Hex,
+} from 'viem'
+import type { ClientWithEns } from '../../contracts/consts.js'
+import { publicResolverAbiSnippet } from '../../contracts/publicResolver.js'
+import type {
+  DecodedAbi,
+  Prettify,
+  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 InternalGetAbiParameters = {
+  /** Name to get ABI record for */
+  name: string
+}
+
+export type InternalGetAbiReturnType = Prettify<DecodedAbi | null>
+
+// Supported content types as bitwise OR
+// ID 1: JSON
+// ID 2: zlib compressed JSON
+// ID 4: CBOR
+// ID 8: URI
+const supportedContentTypes = BigInt('0xf')
+
+const encode = (
+  _client: ClientWithEns,
+  { name }: InternalGetAbiParameters,
+): SimpleTransactionRequest => {
+  return {
+    to: EMPTY_ADDRESS,
+    data: encodeFunctionData({
+      abi: publicResolverAbiSnippet,
+      functionName: 'ABI',
+      args: [namehash(name), supportedContentTypes],
+    }),
+  }
+}
+
+const decode = async (
+  _client: ClientWithEns,
+  data: Hex,
+): Promise<InternalGetAbiReturnType> => {
+  if (data === '0x') return null
+
+  const [bigintContentType, encodedAbiData] = decodeFunctionResult({
+    abi: publicResolverAbiSnippet,
+    functionName: 'ABI',
+    data,
+  })
+
+  if (!bigintContentType || !encodedAbiData) {
+    return null
+  }
+
+  const contentType = Number(bigintContentType)
+  if (!contentType) {
+    return null
+  }
+
+  let abiData: string | object
+  let decoded = false
+  switch (contentType) {
+    // JSON
+    case 1:
+      abiData = JSON.parse(hexToString(encodedAbiData))
+      decoded = true
+      break
+    // zlib compressed JSON
+    case 2: {
+      const { inflate } = await import('pako/dist/pako_inflate.min.js')
+      abiData = JSON.parse(
+        inflate(hexToBytes(encodedAbiData), { to: 'string' }),
+      )
+      decoded = true
+      break
+    }
+    // CBOR
+    case 4: {
+      const { decodeFirst } = await import('cbor')
+      abiData = await decodeFirst(hexToBytes(encodedAbiData))
+      decoded = true
+      break
+    }
+    // URI
+    case 8:
+      abiData = hexToString(encodedAbiData)
+      decoded = true
+      break
+    default:
+      try {
+        abiData = hexToString(encodedAbiData)
+        decoded = true
+      } catch {
+        abiData = encodedAbiData
+      }
+  }
+
+  return {
+    contentType,
+    decoded,
+    abi: abiData,
+  }
+}
+
+const _getAbi = generateFunction({ encode, decode })
+
+export default _getAbi

package/src/functions/public/_getAddr.ts

@@ -0,0 +1,121 @@
+import { formatsByCoinType, formatsByName } from '@ensdomains/address-encoder'
+import { decodeFunctionResult, encodeFunctionData, trim, type Hex } from 'viem'
+import { namehash } from '../../utils/normalise.js'
+
+import type { ClientWithEns } from '../../contracts/consts.js'
+import {
+  publicResolverMultiAddrSnippet,
+  publicResolverSingleAddrSnippet,
+} from '../../contracts/publicResolver.js'
+import { CoinFormatterNotFoundError } from '../../errors/public.js'
+import type {
+  DecodedAddr,
+  Prettify,
+  SimpleTransactionRequest,
+} from '../../types.js'
+import { EMPTY_ADDRESS } from '../../utils/consts.js'
+import { generateFunction } from '../../utils/generateFunction.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
+}
+
+export type InternalGetAddrReturnType = Prettify<DecodedAddr | null>
+
+const encode = (
+  _client: ClientWithEns,
+  { name, coin = 60, bypassFormat }: InternalGetAddrParameters,
+): SimpleTransactionRequest => {
+  if (coin === 60 || coin === '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)],
+      }),
+    }
+  }
+  const formatter =
+    typeof coin === 'string' && Number.isNaN(parseInt(coin))
+      ? formatsByName[coin]
+      : formatsByCoinType[typeof coin === 'number' ? coin : parseInt(coin)]
+
+  if (!formatter) throw new CoinFormatterNotFoundError({ coinType: coin })
+
+  return {
+    to: EMPTY_ADDRESS,
+    data: encodeFunctionData({
+      abi: publicResolverMultiAddrSnippet,
+      functionName: 'addr',
+      args: [namehash(name), BigInt(formatter.coinType)],
+    }),
+  }
+}
+
+const decode = async (
+  _client: ClientWithEns,
+  data: Hex,
+  { coin }: InternalGetAddrParameters,
+): Promise<InternalGetAddrReturnType> => {
+  if (data === '0x') return null
+  if (!coin) {
+    coin = 60
+  }
+
+  const formatter =
+    typeof coin === 'string' && Number.isNaN(parseInt(coin))
+      ? formatsByName[coin]
+      : formatsByCoinType[typeof coin === 'number' ? coin : parseInt(coin)]
+
+  let response: Hex
+
+  if (coin === 60 || coin === '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 = formatter.encoder(Buffer.from(response.slice(2), 'hex'))
+
+  if (!decodedAddr) {
+    return null
+  }
+
+  return { id: formatter.coinType, name: formatter.name, value: decodedAddr }
+}
+
+const _getAddr = generateFunction({ encode, decode })
+
+export default _getAddr

package/src/functions/public/_getContentHash.ts

@@ -0,0 +1,52 @@
+import { decodeFunctionResult, encodeFunctionData, type Hex } 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 {
+  decodeContentHash,
+  type DecodedContentHash,
+} 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
+}
+
+export type InternalGetContentHashReturnType =
+  Prettify<DecodedContentHash | null>
+
+const encode = (
+  _client: ClientWithEns,
+  { name }: InternalGetContentHashParameters,
+): SimpleTransactionRequest => {
+  return {
+    to: EMPTY_ADDRESS,
+    data: encodeFunctionData({
+      abi: publicResolverContenthashSnippet,
+      functionName: 'contenthash',
+      args: [namehash(name)],
+    }),
+  }
+}
+
+const decode = async (
+  _client: ClientWithEns,
+  data: Hex,
+): Promise<InternalGetContentHashReturnType> => {
+  if (data === '0x') return null
+
+  const response = decodeFunctionResult({
+    abi: publicResolverContenthashSnippet,
+    functionName: 'contenthash',
+    data,
+  })
+
+  return decodeContentHash(response)
+}
+
+const _getContentHash = generateFunction({ encode, decode })
+
+export default _getContentHash

package/src/functions/public/_getText.ts

@@ -0,0 +1,51 @@
+import { decodeFunctionResult, encodeFunctionData, type Hex } 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
+}
+
+export type InternalGetTextReturnType = string | null
+
+const encode = (
+  _client: ClientWithEns,
+  { name, key }: InternalGetTextParameters,
+): SimpleTransactionRequest => {
+  return {
+    to: EMPTY_ADDRESS,
+    data: encodeFunctionData({
+      abi: publicResolverTextSnippet,
+      functionName: 'text',
+      args: [namehash(name), key],
+    }),
+  }
+}
+
+const decode = async (
+  _client: ClientWithEns,
+  data: Hex,
+): Promise<InternalGetTextReturnType> => {
+  if (data === '0x') return null
+
+  const response = decodeFunctionResult({
+    abi: publicResolverTextSnippet,
+    functionName: 'text',
+    data,
+  })
+
+  if (!response) return null
+
+  return response
+}
+
+const _getText = generateFunction({ encode, decode })
+
+export default _getText

package/src/functions/public/batch.ts

@@ -0,0 +1,100 @@
+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 {
+  generateFunction,
+  type BatchFunctionResult,
+  type GeneratedFunction,
+} 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, batch, getTextRecord, getAddressRecord } from '@ensdomains/ensjs'
+ *
+ * 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

@@ -0,0 +1,65 @@
+import type { Hex } from 'viem'
+import type { ClientWithEns } from '../../contracts/consts.js'
+import type {
+  GenericPassthrough,
+  Prettify,
+  SimpleTransactionRequest,
+} from '../../types.js'
+import {
+  generateFunction,
+  type GeneratedFunction,
+} from '../../utils/generateFunction.js'
+import _getAbi, {
+  type InternalGetAbiParameters,
+  type InternalGetAbiReturnType,
+} from './_getAbi.js'
+import universalWrapper from './universalWrapper.js'
+
+export type GetAbiRecordParameters = Prettify<InternalGetAbiParameters>
+
+export type GetAbiRecordReturnType = Prettify<InternalGetAbiReturnType>
+
+const encode = (
+  client: ClientWithEns,
+  { name }: GetAbiRecordParameters,
+): SimpleTransactionRequest => {
+  const prData = _getAbi.encode(client, { name })
+  return universalWrapper.encode(client, { name, data: prData.data })
+}
+
+const decode = async (
+  client: ClientWithEns,
+  data: Hex,
+  passthrough: GenericPassthrough,
+): Promise<GetAbiRecordReturnType> => {
+  const urData = await universalWrapper.decode(client, data, passthrough)
+  return _getAbi.decode(client, urData.data)
+}
+
+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, getAbiRecord } from '@ensdomains/ensjs'
+ *
+ * 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 }: GetAbiRecordParameters,
+) => Promise<GetAbiRecordReturnType>) &
+  BatchableFunctionObject
+
+export default getAbiRecord

package/src/functions/public/getAddressRecord.ts

@@ -0,0 +1,66 @@
+import type { Hex } from 'viem'
+import type { ClientWithEns } from '../../contracts/consts.js'
+import type {
+  GenericPassthrough,
+  Prettify,
+  SimpleTransactionRequest,
+} from '../../types.js'
+import {
+  generateFunction,
+  type GeneratedFunction,
+} from '../../utils/generateFunction.js'
+import _getAddr, {
+  type InternalGetAddrParameters,
+  type InternalGetAddrReturnType,
+} from './_getAddr.js'
+import universalWrapper from './universalWrapper.js'
+
+export type GetAddressRecordParameters = Prettify<InternalGetAddrParameters>
+
+export type GetAddressRecordReturnType = Prettify<InternalGetAddrReturnType>
+
+const encode = (
+  client: ClientWithEns,
+  { name, coin }: GetAddressRecordParameters,
+): SimpleTransactionRequest => {
+  const prData = _getAddr.encode(client, { name, coin })
+  return universalWrapper.encode(client, { name, data: prData.data })
+}
+
+const decode = async (
+  client: ClientWithEns,
+  data: Hex,
+  passthrough: GenericPassthrough,
+  args: GetAddressRecordParameters,
+): Promise<GetAddressRecordReturnType> => {
+  const urData = await universalWrapper.decode(client, data, passthrough)
+  return _getAddr.decode(client, urData.data, args)
+}
+
+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, getAddressRecord } from '@ensdomains/ensjs'
+ *
+ * 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 }: GetAddressRecordParameters,
+) => Promise<GetAddressRecordReturnType>) &
+  BatchableFunctionObject
+
+export default getAddressRecord

package/src/functions/public/getAvailable.ts

@@ -0,0 +1,91 @@
+import {
+  BaseError,
+  decodeFunctionResult,
+  encodeFunctionData,
+  labelhash,
+  type Hex,
+} 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 {
+  generateFunction,
+  type GeneratedFunction,
+} 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, getAvailable } from '@ensdomains/ensjs'
+ *
+ * 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