@ensdomains/ensjs 4.1.1 → 5.0.0-alpha.0

package/src/utils/generateFunction.ts

@@ -1,83 +0,0 @@
-import { BaseError } from 'viem'
-import { call } from 'viem/actions'
-import type { ClientWithEns } from '../contracts/consts.js'
-import type { TransactionRequestWithPassthrough } from '../types.js'
-
-export type EncoderFunction = (
-  ...args: any[]
-) => TransactionRequestWithPassthrough
-export type DecoderFunction = (...args: any[]) => Promise<any>
-
-type OmitFirstArg<F> = F extends (x: any, ...args: infer P) => infer R
-  ? (...args: P) => R
-  : never
-
-export type CoderObject<
-  TEncoderFn extends EncoderFunction = EncoderFunction,
-  TDecoderFn extends DecoderFunction = DecoderFunction,
-> = {
-  encode: TEncoderFn
-  decode: TDecoderFn
-}
-
-export type BatchFunctionResult<
-  TEncoderFn extends EncoderFunction = EncoderFunction,
-  TDecoderFn extends DecoderFunction = DecoderFunction,
-> = {
-  args: Parameters<OmitFirstArg<TEncoderFn>>
-} & CoderObject<TEncoderFn, TDecoderFn>
-
-export type ExtractResult<TFunction extends Function> = TFunction extends (
-  ...args: any[]
-) => Promise<infer U>
-  ? U
-  : never
-
-export interface GeneratedFunction<
-  TEncoderFn extends EncoderFunction,
-  TDecoderFn extends DecoderFunction,
-> extends Function,
-    CoderObject<TEncoderFn, TDecoderFn> {
-  (
-    client: ClientWithEns,
-    ...args: Parameters<OmitFirstArg<TEncoderFn>>
-  ): Promise<ExtractResult<TDecoderFn> | null>
-  batch: (
-    ...args: Parameters<OmitFirstArg<TEncoderFn>>
-  ) => BatchFunctionResult<TEncoderFn, TDecoderFn>
-}
-
-export const generateFunction = <
-  TEncoderFn extends EncoderFunction,
-  TDecoderFn extends DecoderFunction,
-  TFunction extends GeneratedFunction<
-    TEncoderFn,
-    TDecoderFn
-  > = GeneratedFunction<TEncoderFn, TDecoderFn>,
->({
-  encode,
-  decode,
-}: {
-  encode: TEncoderFn
-  decode: TDecoderFn
-}) => {
-  const single = (async (client, ...args) => {
-    const { passthrough, ...encodedData } = encode(client, ...args)
-    const result = await call(client, encodedData)
-      .then((ret) => ret.data)
-      .catch((e) => {
-        if (!(e instanceof BaseError)) throw e
-        return e
-      })
-    if (passthrough) return decode(client, result, passthrough, ...args)
-    return decode(client, result, ...args)
-  }) as TFunction
-  single.batch = (...args) => ({
-    args,
-    encode,
-    decode,
-  })
-  single.encode = encode
-  single.decode = decode
-  return single
-}

package/src/utils/generateRecordCallArray.ts

@@ -1,74 +0,0 @@
-import type { Hex } from 'viem'
-import type { Prettify } from '../types.js'
-import type { EncodedAbi } from './encoders/encodeAbi.js'
-import { encodeClearRecords } from './encoders/encodeClearRecords.js'
-import {
-  type EncodeSetAbiParameters,
-  encodeSetAbi,
-} from './encoders/encodeSetAbi.js'
-import {
-  type EncodeSetAddrParameters,
-  encodeSetAddr,
-} from './encoders/encodeSetAddr.js'
-import { encodeSetContentHash } from './encoders/encodeSetContentHash.js'
-import {
-  type EncodeSetTextParameters,
-  encodeSetText,
-} from './encoders/encodeSetText.js'
-
-export type RecordOptions = Prettify<{
-  /** Clears all current records */
-  clearRecords?: boolean
-  /** ContentHash value */
-  contentHash?: string | null
-  /** Array of text records */
-  texts?: Omit<EncodeSetTextParameters, 'namehash'>[]
-  /** Array of coin records */
-  coins?: Omit<EncodeSetAddrParameters, 'namehash'>[]
-  /** ABI value */
-  abi?: EncodedAbi | EncodedAbi[]
-}>
-
-export const generateRecordCallArray = ({
-  namehash,
-  clearRecords,
-  contentHash,
-  texts,
-  coins,
-  abi,
-}: { namehash: Hex } & RecordOptions): Hex[] => {
-  const calls: Hex[] = []
-
-  if (clearRecords) {
-    calls.push(encodeClearRecords(namehash))
-  }
-
-  if (contentHash !== undefined) {
-    const data = encodeSetContentHash({ namehash, contentHash })
-    if (data) calls.push(data)
-  }
-
-  if (abi !== undefined) {
-    const abis = Array.isArray(abi) ? abi : [abi]
-    for (const abi_ of abis) {
-      const data = encodeSetAbi({ namehash, ...abi_ } as EncodeSetAbiParameters)
-      if (data) calls.push(data)
-    }
-  }
-
-  if (texts && texts.length > 0) {
-    const data = texts.map((textItem) =>
-      encodeSetText({ namehash, ...textItem }),
-    )
-    if (data) calls.push(...data)
-  }
-
-  if (coins && coins.length > 0) {
-    const data = coins.map((coinItem) =>
-      encodeSetAddr({ namehash, ...coinItem }),
-    )
-    if (data) calls.push(...data)
-  }
-
-  return calls
-}

package/src/utils/getNameType.ts

@@ -1,18 +0,0 @@
-import type { NameType } from '../types.js'
-
-export const getNameType = (name: string): NameType => {
-  const labels = name.split('.')
-  const isDotEth = labels[labels.length - 1] === 'eth'
-
-  if (labels.length === 0) return 'root'
-  if (labels.length === 1) {
-    if (isDotEth) return 'eth-tld'
-    return 'tld'
-  }
-  if (labels.length === 2) {
-    if (isDotEth) return 'eth-2ld'
-    return 'other-2ld'
-  }
-  if (isDotEth) return 'eth-subname'
-  return 'other-subname'
-}

package/src/utils/getRevertErrorData.ts

@@ -1,9 +0,0 @@
-import { BaseError, type RawContractError } from 'viem'
-
-export const getRevertErrorData = (err: unknown) => {
-  if (!(err instanceof BaseError)) return undefined
-  const error = err.walk() as RawContractError
-  const hex = typeof error.data === 'object' ? error.data.data : error.data
-  if (hex === '0x') return undefined
-  return hex
-}

package/src/utils/hexEncodedName.ts

@@ -1,49 +0,0 @@
-// Adapted from https://github.com/mafintosh/dns-packet
-import { type ByteArray, bytesToString, labelhash, stringToBytes } from 'viem'
-import { encodeLabelhash } from './labels.js'
-
-/*
- * @description Encodes a DNS packet into a ByteArray containing a UDP payload.
- */
-export function packetToBytes(packet: string): ByteArray {
-  // strip leading and trailing `.`
-  const value = packet.replace(/^\.|\.$/gm, '')
-  if (value.length === 0) return new Uint8Array(1)
-
-  const bytes = new Uint8Array(stringToBytes(value).byteLength + 2)
-
-  let offset = 0
-  const list = value.split('.')
-  for (let i = 0; i < list.length; i += 1) {
-    let encoded = stringToBytes(list[i])
-    // if the length is > 255, make the encoded label value a labelhash
-    // this is compatible with the universal resolver
-    if (encoded.byteLength > 255)
-      encoded = stringToBytes(encodeLabelhash(labelhash(list[i])))
-    bytes[offset] = encoded.length
-    bytes.set(encoded, offset + 1)
-    offset += encoded.length + 1
-  }
-
-  if (bytes.byteLength !== offset + 1) return bytes.slice(0, offset + 1)
-
-  return bytes
-}
-
-export function bytesToPacket(bytes: ByteArray): string {
-  let offset = 0
-  let result = ''
-
-  while (offset < bytes.length) {
-    const len = bytes[offset]
-    if (len === 0) {
-      offset += 1
-      break
-    }
-
-    result += `${bytesToString(bytes.subarray(offset + 1, offset + len + 1))}.`
-    offset += len + 1
-  }
-
-  return result.replace(/\.$/, '')
-}

package/src/utils/labels.ts

@@ -1,96 +0,0 @@
-import { type Hex, labelhash } from 'viem'
-import {
-  InvalidEncodedLabelError,
-  InvalidLabelhashError,
-} from '../errors/utils.js'
-
-const hasLocalStorage = typeof localStorage !== 'undefined'
-
-export function decodeLabelhash(hash: string): Hex {
-  if (!(hash.startsWith('[') && hash.endsWith(']')))
-    throw new InvalidEncodedLabelError({
-      label: hash,
-      details:
-        'Expected encoded labelhash to start and end with square brackets',
-    })
-
-  if (hash.length !== 66)
-    throw new InvalidEncodedLabelError({
-      label: hash,
-      details: 'Expected encoded labelhash to have a length of 66',
-    })
-
-  return `0x${hash.slice(1, -1)}`
-}
-
-export function encodeLabelhash(hash: string) {
-  if (!hash.startsWith('0x'))
-    throw new InvalidLabelhashError({
-      labelhash: hash,
-      details: 'Expected labelhash to start with 0x',
-    })
-
-  if (hash.length !== 66)
-    throw new InvalidLabelhashError({
-      labelhash: hash,
-      details: 'Expected labelhash to have a length of 66',
-    })
-
-  return `[${hash.slice(2)}]`
-}
-
-export function isEncodedLabelhash(hash: string) {
-  return hash.startsWith('[') && hash.endsWith(']') && hash.length === 66
-}
-
-function getLabels() {
-  return hasLocalStorage
-    ? JSON.parse(localStorage.getItem('ensjs:labels') as string) || {}
-    : {}
-}
-
-function _saveLabel(hash: string, label: any) {
-  if (!hasLocalStorage) return hash
-  const labels = getLabels()
-  localStorage.setItem(
-    'ensjs:labels',
-    JSON.stringify({
-      ...labels,
-      [hash]: label,
-    }),
-  )
-  return hash
-}
-
-export function saveLabel(label: string) {
-  const hash = `${labelhash(label.toLowerCase())}`
-  return _saveLabel(hash, label)
-}
-
-export function saveName(name: string) {
-  const nameArray = name.split('.')
-  for (const label of nameArray) {
-    if (!isEncodedLabelhash(label)) {
-      saveLabel(label)
-    }
-  }
-}
-
-export function checkLabel(hash: string): string {
-  const labels = getLabels()
-  if (isEncodedLabelhash(hash)) {
-    return labels[decodeLabelhash(hash)] || hash
-  }
-  return hash
-}
-
-export function checkIsDecrypted(string: string | string[]) {
-  return !string?.includes('[')
-}
-
-export function decryptName(name: string) {
-  return name
-    .split('.')
-    .map((label: any) => checkLabel(label))
-    .join('.')
-}

package/src/utils/legacyRegisterHelpers.ts

@@ -1,147 +0,0 @@
-import {
-  type Address,
-  type Hex,
-  encodePacked,
-  keccak256,
-  labelhash,
-} from 'viem'
-import { LegacyRegistrationInvalidConfigError } from '../errors/register.js'
-import { EMPTY_ADDRESS } from './consts.js'
-
-export type LegacyRegistrationParameters = {
-  /** Name to register */
-  name: string
-  /** Address to set owner to */
-  owner: Address
-  /** Duration of registration */
-  duration: number
-  /** Random 32 bytes to use for registration */
-  secret: Hex
-  /** Custom resolver address, defaults to empty address */
-  resolverAddress?: Address
-  /** Address to set upon registration, defaults to empty address */
-  address?: Address
-}
-
-export type LegacyRegistrationWithConfigParameters =
-  LegacyRegistrationParameters & {
-    resolverAddress: Address
-    address?: Address
-  }
-
-export const isLegacyRegistrationWithConfigParameters = (
-  params: LegacyRegistrationParameters,
-): params is LegacyRegistrationWithConfigParameters => {
-  const { resolverAddress = EMPTY_ADDRESS, address = EMPTY_ADDRESS } =
-    params as LegacyRegistrationWithConfigParameters
-
-  if (resolverAddress === EMPTY_ADDRESS && address !== EMPTY_ADDRESS)
-    throw new LegacyRegistrationInvalidConfigError({
-      resolverAddress,
-      address,
-    })
-  return resolverAddress !== EMPTY_ADDRESS || address !== EMPTY_ADDRESS
-}
-
-export type LegacyCommitmentTuple = [label: string, owner: Address, secret: Hex]
-
-export type LegacyCommitmentWithConfigTuple = [
-  label: string,
-  owner: Address,
-  resolverAddress: Address,
-  address: Address,
-  secret: Hex,
-]
-
-export type LegacyRegistrationTuple = [
-  label: string,
-  owner: Address,
-  duration: bigint,
-  secret: Hex,
-]
-
-export type LegacyRegistrationWithConfigTuple = [
-  label: string,
-  owner: Address,
-  duration: bigint,
-  secret: Hex,
-  resolverAddress: Address,
-  address: Address,
-]
-
-export const makeLegacyCommitmentTuple = (
-  params: LegacyRegistrationParameters,
-): LegacyCommitmentTuple => {
-  const { name, owner, secret } = params
-  const label = name.split('.')[0]
-  return [label, owner, secret]
-}
-
-export const makeLegacyCommitmentWithConfigTuple = (
-  params: LegacyRegistrationWithConfigParameters,
-): LegacyCommitmentWithConfigTuple => {
-  const {
-    name,
-    owner,
-    secret,
-    resolverAddress = EMPTY_ADDRESS,
-    address = EMPTY_ADDRESS,
-  } = params as LegacyRegistrationWithConfigParameters
-  const label = name.split('.')[0]
-  return [label, owner, secret, resolverAddress, address]
-}
-
-export const makeLegacyRegistrationTuple = ({
-  name,
-  owner,
-  secret,
-  duration,
-}: LegacyRegistrationParameters): LegacyRegistrationTuple => {
-  const label = name.split('.')[0]
-  return [label, owner, BigInt(duration), secret]
-}
-
-export const makeLegacyRegistrationWithConfigTuple = ({
-  name,
-  owner,
-  secret,
-  duration,
-  resolverAddress,
-  address = EMPTY_ADDRESS,
-}: LegacyRegistrationWithConfigParameters): LegacyRegistrationWithConfigTuple => {
-  const label = name.split('.')[0]
-  return [label, owner, BigInt(duration), secret, resolverAddress, address]
-}
-
-export const makeLegacyCommitmentFromTuple = ([label, ...others]:
-  | LegacyCommitmentTuple
-  | LegacyCommitmentWithConfigTuple): Hex => {
-  const labelHash = labelhash(label)
-  const params = [labelHash, ...others] as const
-
-  if (params.length === 3)
-    return keccak256(encodePacked(['bytes32', 'address', 'bytes32'], params))
-
-  const [
-    owner,
-    secret,
-    resolverAddress = EMPTY_ADDRESS,
-    address = EMPTY_ADDRESS,
-  ] = others
-
-  return keccak256(
-    encodePacked(
-      ['bytes32', 'address', 'address', 'address', 'bytes32'],
-      [labelHash, owner, resolverAddress, address, secret],
-    ),
-  )
-}
-
-export const makeLegacyCommitment = (
-  params: LegacyRegistrationParameters | LegacyRegistrationWithConfigParameters,
-): Hex => {
-  const touple = isLegacyRegistrationWithConfigParameters(params)
-    ? makeLegacyCommitmentWithConfigTuple(params)
-    : makeLegacyCommitmentTuple(params)
-  return makeLegacyCommitmentFromTuple(touple)
-}

package/src/utils/makeLabelNodeAndParent.ts

@@ -1,13 +0,0 @@
-import { labelhash } from 'viem'
-import { namehash } from './normalise.js'
-
-export const makeLabelNodeAndParent = (name: string) => {
-  const labels = name.split('.')
-  const label = labels.shift() as string
-  const parentNode = namehash(labels.join('.'))
-  return {
-    label,
-    labelhash: labelhash(label),
-    parentNode,
-  }
-}

package/src/utils/makeSafeSecondsDate.ts

@@ -1,7 +0,0 @@
-import { MAX_DATE_INT } from './consts.js'
-
-export const makeSafeSecondsDate = (seconds: number | bigint) => {
-  const milliseconds = BigInt(seconds) * 1000n
-  if (milliseconds > BigInt(MAX_DATE_INT)) return new Date(MAX_DATE_INT)
-  return new Date(Number(milliseconds))
-}

package/src/utils/normalise.ts

@@ -1,75 +0,0 @@
-import {
-  type DisallowedToken,
-  type EmojiToken,
-  type IgnoredToken,
-  type Label,
-  type MappedToken,
-  type NFCToken,
-  type StopToken,
-  type TextToken,
-  type Token,
-  type ValidToken,
-  ens_beautify,
-  ens_emoji,
-  ens_normalize,
-  ens_normalize_fragment,
-  ens_split,
-  ens_tokenize,
-  is_combining_mark,
-  should_escape,
-} from '@adraffy/ens-normalize'
-import {
-  type ByteArray,
-  bytesToHex,
-  concat,
-  hexToBytes,
-  keccak256,
-  stringToBytes,
-} from 'viem'
-import { decodeLabelhash, isEncodedLabelhash } from './labels.js'
-
-const zeros = new Uint8Array(32)
-zeros.fill(0)
-
-export const normalise = (name: string) => (name ? ens_normalize(name) : name)
-
-export function namehash(name: string) {
-  let result: ByteArray = new Uint8Array(32).fill(0)
-  if (!name) return bytesToHex(result)
-
-  const labels = name.split('.')
-  // Iterate in reverse order building up hash
-  for (let i = labels.length - 1; i >= 0; i -= 1) {
-    let labelSha: Uint8Array
-    if (isEncodedLabelhash(labels[i])) {
-      labelSha = hexToBytes(decodeLabelhash(labels[i]))
-    } else {
-      const normalised = normalise(labels[i])
-      labelSha = keccak256(stringToBytes(normalised), 'bytes')
-    }
-    result = keccak256(concat([result, labelSha]), 'bytes')
-  }
-
-  return bytesToHex(result)
-}
-
-export const beautify = ens_beautify
-export const emoji = ens_emoji
-export const normaliseFragment = ens_normalize_fragment
-export const split = ens_split
-export const tokenise = ens_tokenize
-export const isCombiningMark = is_combining_mark
-export const shouldEscape = should_escape
-
-export type {
-  DisallowedToken,
-  EmojiToken,
-  IgnoredToken,
-  Label,
-  MappedToken,
-  NFCToken,
-  StopToken,
-  TextToken,
-  Token,
-  ValidToken,
-}

package/src/utils/normaliseCoinId.ts

@@ -1,36 +0,0 @@
-import {
-  type Coin,
-  getCoderByCoinName,
-  getCoderByCoinType,
-} from '@ensdomains/address-encoder'
-import { CoinFormatterNotFoundError } from '../errors/public.js'
-
-export const normaliseCoinId = (coinId: string | number) => {
-  const isString = typeof coinId === 'string'
-
-  if (isString && Number.isNaN(Number.parseInt(coinId))) {
-    return {
-      type: 'name',
-      value: coinId.toLowerCase().replace(/legacy$/, 'Legacy'),
-    } as const
-  }
-  return {
-    type: 'id',
-    value: isString ? Number.parseInt(coinId as string) : (coinId as number),
-  } as const
-}
-
-export const getCoderFromCoin = (coinId: string | number): Coin => {
-  const normalisedCoin = normaliseCoinId(coinId)
-  let coder: Coin
-  try {
-    coder =
-      normalisedCoin.type === 'id'
-        ? getCoderByCoinType(normalisedCoin.value)
-        : getCoderByCoinName(normalisedCoin.value)
-  } catch {
-    throw new CoinFormatterNotFoundError({ coinType: coinId })
-  }
-
-  return coder
-}

package/src/utils/validation.ts

@@ -1,79 +0,0 @@
-import {
-  NameWithEmptyLabelsError,
-  RootNameIncludesOtherLabelsError,
-} from '../errors/utils.js'
-import { MINIMUM_DOT_ETH_CHARS } from './consts.js'
-import { checkLabel, isEncodedLabelhash, saveName } from './labels.js'
-import { type Label, normalise, split } from './normalise.js'
-
-export const validateName = (name: string) => {
-  const nameArray = name.split('.')
-  const normalisedArray = nameArray.map((label) => {
-    if (label.length === 0) throw new NameWithEmptyLabelsError({ name })
-    if (label === '[root]') {
-      if (name !== label) throw new RootNameIncludesOtherLabelsError({ name })
-      return label
-    }
-    return isEncodedLabelhash(label)
-      ? checkLabel(label) || label
-      : normalise(label)
-  })
-  const normalisedName = normalisedArray.join('.')
-  saveName(normalisedName)
-  return normalisedName
-}
-
-export type ParsedInputResult = {
-  type: 'name' | 'label'
-  normalised: string | undefined
-  isValid: boolean
-  isShort: boolean
-  is2LD: boolean
-  isETH: boolean
-  labelDataArray: Label[]
-}
-
-export const parseInput = (input: string): ParsedInputResult => {
-  let nameReference = input
-  let isValid = false
-
-  try {
-    nameReference = validateName(input)
-    isValid = true
-  } catch {}
-
-  const normalisedName = isValid ? nameReference : undefined
-
-  const labels = nameReference.split('.')
-  const tld = labels[labels.length - 1]
-  const isETH = tld === 'eth'
-  const labelDataArray = split(nameReference)
-  const isShort =
-    (labelDataArray[0].output?.length || 0) < MINIMUM_DOT_ETH_CHARS
-
-  if (labels.length === 1) {
-    return {
-      type: 'label',
-      normalised: normalisedName,
-      isShort,
-      isValid,
-      is2LD: false,
-      isETH,
-      labelDataArray,
-    }
-  }
-
-  const is2LD = labels.length === 2
-  return {
-    type: 'name',
-    normalised: normalisedName,
-    isShort: isETH && is2LD ? isShort : false,
-    isValid,
-    is2LD,
-    isETH,
-    labelDataArray,
-  }
-}
-
-export const checkIsDotEth = (labels: string[]) =>
-  labels.length === 2 && labels[1] === 'eth'