@ensdomains/ensjs 4.1.1 → 5.0.0-alpha.0

package/src/functions/wallet/wrapName.ts

@@ -1,189 +0,0 @@
-import {
-  type Account,
-  type Address,
-  type Hash,
-  type SendTransactionParameters,
-  type Transport,
-  encodeAbiParameters,
-  encodeFunctionData,
-  labelhash,
-  toHex,
-} from 'viem'
-import { sendTransaction } from 'viem/actions'
-import { parseAccount } from 'viem/utils'
-import { baseRegistrarSafeTransferFromWithDataSnippet } from '../../contracts/baseRegistrar.js'
-import type { ChainWithEns, ClientWithAccount } from '../../contracts/consts.js'
-import { getChainContractAddress } from '../../contracts/getChainContractAddress.js'
-import { nameWrapperWrapSnippet } from '../../contracts/nameWrapper.js'
-import { AdditionalParameterSpecifiedError } from '../../errors/general.js'
-import type {
-  Eth2ldNameSpecifier,
-  GetNameType,
-  Prettify,
-  SimpleTransactionRequest,
-  WriteTransactionParameters,
-} from '../../types.js'
-import {
-  type EncodeChildFusesInputObject,
-  encodeFuses,
-} from '../../utils/fuses.js'
-import { packetToBytes } from '../../utils/hexEncodedName.js'
-import { checkIsDotEth } from '../../utils/validation.js'
-import { wrappedLabelLengthCheck } from '../../utils/wrapper.js'
-
-export type WrapNameDataParameters<
-  TName extends string,
-  TNameOption extends GetNameType<TName> = GetNameType<TName>,
-> = {
-  /** The name to wrap */
-  name: TName
-  /** The recipient of the wrapped name */
-  newOwnerAddress: Address
-  /** Fuses to set on wrap (eth-2ld only) */
-  fuses?: TNameOption extends Eth2ldNameSpecifier
-    ? EncodeChildFusesInputObject
-    : never
-  /** The resolver address to set on wrap */
-  resolverAddress?: Address
-}
-
-export type WrapNameDataReturnType = SimpleTransactionRequest
-
-export type WrapNameParameters<
-  TName extends string,
-  TChain extends ChainWithEns,
-  TAccount extends Account | undefined,
-  TChainOverride extends ChainWithEns | undefined,
-> = Prettify<
-  WrapNameDataParameters<TName> &
-    WriteTransactionParameters<TChain, TAccount, TChainOverride>
->
-
-export type WrapNameReturnType = Hash
-
-export const makeFunctionData = <
-  TName extends string,
-  TChain extends ChainWithEns,
-  TAccount extends Account,
->(
-  wallet: ClientWithAccount<Transport, TChain, TAccount>,
-  {
-    name,
-    newOwnerAddress,
-    fuses,
-    resolverAddress = getChainContractAddress({
-      client: wallet,
-      contract: 'ensPublicResolver',
-    }),
-  }: WrapNameDataParameters<TName>,
-): WrapNameDataReturnType => {
-  const labels = name.split('.')
-  const isEth2ld = checkIsDotEth(labels)
-
-  const nameWrapperAddress = getChainContractAddress({
-    client: wallet,
-    contract: 'ensNameWrapper',
-  })
-
-  if (isEth2ld) {
-    wrappedLabelLengthCheck(labels[0])
-    const encodedFuses = fuses
-      ? encodeFuses({ restriction: 'child', input: fuses })
-      : 0
-    const tokenId = BigInt(labelhash(labels[0]))
-
-    const data = encodeAbiParameters(
-      [
-        { name: 'label', type: 'string' },
-        { name: 'wrappedOwner', type: 'address' },
-        { name: 'ownerControlledFuses', type: 'uint16' },
-        { name: 'resolverAddress', type: 'address' },
-      ],
-      [labels[0], newOwnerAddress, encodedFuses, resolverAddress],
-    )
-
-    return {
-      to: getChainContractAddress({
-        client: wallet,
-        contract: 'ensBaseRegistrarImplementation',
-      }),
-      data: encodeFunctionData({
-        abi: baseRegistrarSafeTransferFromWithDataSnippet,
-        functionName: 'safeTransferFrom',
-        args: [wallet.account.address, nameWrapperAddress, tokenId, data],
-      }),
-    }
-  }
-
-  if (fuses)
-    throw new AdditionalParameterSpecifiedError({
-      parameter: 'fuses',
-      allowedParameters: ['name', 'wrappedOwner', 'resolverAddress'],
-      details: 'Fuses cannot be initially set when wrapping non eth-2ld names',
-    })
-
-  labels.forEach((label) => wrappedLabelLengthCheck(label))
-  return {
-    to: nameWrapperAddress,
-    data: encodeFunctionData({
-      abi: nameWrapperWrapSnippet,
-      functionName: 'wrap',
-      args: [toHex(packetToBytes(name)), newOwnerAddress, resolverAddress],
-    }),
-  }
-}
-
-/**
- * Wraps a name.
- * @param wallet - {@link ClientWithAccount}
- * @param parameters - {@link WrapNameParameters}
- * @returns Transaction hash. {@link WrapNameReturnType}
- *
- * @example
- * import { createWalletClient, custom } from 'viem'
- * import { mainnet } from 'viem/chains'
- * import { addEnsContracts } from '@ensdomains/ensjs'
- * import { wrapName } from '@ensdomains/ensjs/wallet'
- *
- * const wallet = createWalletClient({
- *   chain: addEnsContracts(mainnet),
- *   transport: custom(window.ethereum),
- * })
- * const hash = await wrapName(wallet, {
- *   name: 'ens.eth',
- *   newOwnerAddress: '0xFe89cc7aBB2C4183683ab71653C4cdc9B02D44b7',
- * })
- * // 0x...
- */
-async function wrapName<
-  TName extends string,
-  TChain extends ChainWithEns,
-  TAccount extends Account | undefined,
-  TChainOverride extends ChainWithEns | undefined = ChainWithEns,
->(
-  wallet: ClientWithAccount<Transport, TChain, TAccount>,
-  {
-    name,
-    newOwnerAddress,
-    fuses,
-    resolverAddress,
-    ...txArgs
-  }: WrapNameParameters<TName, TChain, TAccount, TChainOverride>,
-): Promise<WrapNameReturnType> {
-  const data = makeFunctionData(
-    {
-      ...wallet,
-      account: parseAccount((txArgs.account || wallet.account)!),
-    } as ClientWithAccount<Transport, TChain, Account>,
-    { name, newOwnerAddress, fuses, resolverAddress },
-  )
-  const writeArgs = {
-    ...data,
-    ...txArgs,
-  } as SendTransactionParameters<TChain, TAccount, TChainOverride>
-  return sendTransaction(wallet, writeArgs)
-}
-
-wrapName.makeFunctionData = makeFunctionData
-
-export default wrapName

package/src/public.ts

@@ -1,100 +0,0 @@
-export {
-  default as _getAbi,
-  type InternalGetAbiParameters,
-  type InternalGetAbiReturnType,
-} from './functions/public/_getAbi.js'
-export {
-  default as _getAddr,
-  type InternalGetAddrParameters,
-  type InternalGetAddrReturnType,
-} from './functions/public/_getAddr.js'
-export {
-  default as _getContentHash,
-  type InternalGetContentHashParameters,
-  type InternalGetContentHashReturnType,
-} from './functions/public/_getContentHash.js'
-export {
-  default as _getText,
-  type InternalGetTextParameters,
-  type InternalGetTextReturnType,
-} from './functions/public/_getText.js'
-export {
-  default as batch,
-  type BatchParameters,
-  type BatchReturnType,
-} from './functions/public/batch.js'
-export {
-  default as getAbiRecord,
-  type GetAbiRecordParameters,
-  type GetAbiRecordReturnType,
-} from './functions/public/getAbiRecord.js'
-export {
-  default as getAddressRecord,
-  type GetAddressRecordParameters,
-  type GetAddressRecordReturnType,
-} from './functions/public/getAddressRecord.js'
-export {
-  default as getAvailable,
-  type GetAvailableParameters,
-  type GetAvailableReturnType,
-} from './functions/public/getAvailable.js'
-export {
-  default as getContentHashRecord,
-  type GetContentHashRecordParameters,
-  type GetContentHashRecordReturnType,
-} from './functions/public/getContentHashRecord.js'
-export {
-  default as getExpiry,
-  type GetExpiryParameters,
-  type GetExpiryReturnType,
-} from './functions/public/getExpiry.js'
-export {
-  default as getName,
-  type GetNameParameters,
-  type GetNameReturnType,
-} from './functions/public/getName.js'
-export {
-  default as getOwner,
-  type GetOwnerParameters,
-  type GetOwnerReturnType,
-} from './functions/public/getOwner.js'
-export {
-  default as getPrice,
-  type GetPriceParameters,
-  type GetPriceReturnType,
-} from './functions/public/getPrice.js'
-export {
-  default as getRecords,
-  type GetRecordsParameters,
-  type GetRecordsReturnType,
-} from './functions/public/getRecords.js'
-export {
-  default as getResolver,
-  type GetResolverParameters,
-  type GetResolverReturnType,
-} from './functions/public/getResolver.js'
-export {
-  default as getSupportedInterfaces,
-  type GetSupportedInterfacesParameters,
-  type GetSupportedInterfacesReturnType,
-} from './functions/public/getSupportedInterfaces.js'
-export {
-  default as getTextRecord,
-  type GetTextRecordParameters,
-  type GetTextRecordReturnType,
-} from './functions/public/getTextRecord.js'
-export {
-  default as getWrapperData,
-  type GetWrapperDataParameters,
-  type GetWrapperDataReturnType,
-} from './functions/public/getWrapperData.js'
-export {
-  default as multicallWrapper,
-  type MulticallWrapperParameters,
-  type MulticallWrapperReturnType,
-} from './functions/public/multicallWrapper.js'
-export {
-  default as universalWrapper,
-  type UniversalWrapperParameters,
-  type UniversalWrapperReturnType,
-} from './functions/public/universalWrapper.js'

package/src/types.ts

@@ -1,131 +0,0 @@
-import type {
-  Account,
-  Address,
-  Client,
-  SendTransactionParameters,
-  TransactionRequest,
-} from 'viem'
-import type { ChainWithEns } from './contracts/consts.js'
-
-export type Prettify<T> = {
-  [K in keyof T]: T[K]
-} & {}
-
-type AssignI<T, U> = {
-  [K in keyof T as K extends keyof U
-    ? U[K] extends void
-      ? never
-      : K
-    : K]: K extends keyof U ? U[K] : T[K]
-}
-
-export type Assign<T, U> = AssignI<T, U> & U
-
-export type SimpleTransactionRequest = {
-  [P in keyof Pick<TransactionRequest, 'to' | 'data'>]-?: Exclude<
-    TransactionRequest[P],
-    null
-  >
-}
-
-export type TransactionRequestWithPassthrough<TPassthrough = any> =
-  SimpleTransactionRequest & {
-    passthrough?: TPassthrough
-  }
-
-export type GenericPassthrough = { args: any; address: Address }
-
-export type Extended = { [K in keyof Client]?: undefined } & {
-  [key: string]: unknown
-}
-
-type AllowedWriteParameters =
-  | 'gas'
-  | 'gasPrice'
-  | 'maxFeePerGas'
-  | 'maxPriorityFeePerGas'
-  | 'nonce'
-  | 'account'
-
-export type WriteTransactionParameters<
-  TChain extends ChainWithEns,
-  TAccount extends Account | undefined,
-  TChainOverride extends ChainWithEns | undefined = ChainWithEns,
-> = Pick<
-  SendTransactionParameters<TChain, TAccount, TChainOverride>,
-  AllowedWriteParameters
->
-
-export type DateWithValue<T> = {
-  date: Date
-  value: T
-}
-
-export type DecodedAbi = {
-  contentType: 1 | 2 | 4 | 8 | number
-  decoded: boolean
-  abi: string | object
-}
-
-export type DecodedAddr = {
-  id: number
-  name: string
-  value: string
-}
-
-export type DecodedText = {
-  key: string
-  value: string
-}
-
-export type AnyDate = string | number | bigint | Date
-
-export type RootName = ''
-export type TldName = `${string}`
-export type EthTldName = `eth`
-export type Eth2ldName = `${string}.eth`
-export type EthAnyName = EthTldName | Eth2ldName
-export type EthSubname = `${string}.${string}.eth`
-export type Other2ldName = `${string}.${string}`
-export type OtherSubname = `${string}.${string}.${string}`
-
-export type NameOption =
-  | TldName
-  | Eth2ldName
-  | EthSubname
-  | Other2ldName
-  | OtherSubname
-
-export type TldNameSpecifier = 'tld'
-export type Eth2ldNameSpecifier = 'eth-2ld'
-export type EthSubnameSpecifier = 'eth-subname'
-export type Other2ldNameSpecifier = 'other-2ld'
-export type OtherSubnameSpecifier = 'other-subname'
-export type RootNameSpecifier = 'root'
-export type EthTldNameSpecifier = 'eth-tld'
-
-export type NameType =
-  | TldNameSpecifier
-  | Eth2ldNameSpecifier
-  | EthSubnameSpecifier
-  | Other2ldNameSpecifier
-  | OtherSubnameSpecifier
-  | RootNameSpecifier
-  | EthTldNameSpecifier
-
-type GetEthNameType<TString extends EthAnyName> = TString extends EthTldName
-  ? EthTldNameSpecifier
-  : TString extends EthSubname
-    ? EthSubnameSpecifier
-    : Eth2ldNameSpecifier
-type GetOtherNameType<TString extends TldName> = TString extends OtherSubname
-  ? OtherSubnameSpecifier
-  : TString extends Other2ldName
-    ? Other2ldNameSpecifier
-    : TldNameSpecifier
-
-export type GetNameType<TString extends string> = TString extends RootName
-  ? RootNameSpecifier
-  : TString extends EthAnyName
-    ? GetEthNameType<TString>
-    : GetOtherNameType<TString>

package/src/utils/checkSafeUniversalResolverData.ts

@@ -1,62 +0,0 @@
-import {
-  type BaseError,
-  CallExecutionError,
-  type Hex,
-  decodeErrorResult,
-  getContractError,
-} from 'viem'
-import type { Prettify } from '../types.js'
-import { getRevertErrorData } from './getRevertErrorData.js'
-
-type CheckSafeUniversalResolverDataParameters = Prettify<
-  {
-    strict: boolean | undefined
-    args: any[] | (() => any[])
-  } & Omit<Parameters<typeof getContractError>[1], 'args'>
->
-
-/**
- * Checks if the data returned from a universal resolver is safe to use, or if it is a known revert error
- * @param parameters - {@link CheckSafeUniversalResolverDataParameters}
- * @returns `true` if the data is safe to use, `false` if it is a known revert error, or throws if it is an unknown error
- */
-export const checkSafeUniversalResolverData = (
-  data: Hex | BaseError,
-  {
-    strict,
-    abi,
-    args,
-    functionName,
-    address,
-    docsPath,
-    sender,
-  }: CheckSafeUniversalResolverDataParameters,
-): data is Hex => {
-  if (typeof data === 'object') {
-    // if not strict, attempt to check if the error is a known revert error before throwing
-    // if it is a known revert error, return false instead of throwing
-    // even if strict is false, we want to throw unknown contract errors
-    if (!strict) {
-      const errorData = getRevertErrorData(data)
-      if (errorData) {
-        try {
-          decodeErrorResult({
-            abi,
-            data: errorData,
-          })
-          return false
-        } catch (_error) {}
-      }
-    }
-    if (data instanceof CallExecutionError) throw data
-    throw getContractError(data, {
-      abi,
-      args: typeof args === 'function' ? args() : args,
-      functionName,
-      address,
-      docsPath,
-      sender,
-    }) as BaseError
-  }
-  return true
-}

package/src/utils/encoders/encodeAbi.ts

@@ -1,104 +0,0 @@
-import { type Hex, bytesToHex, stringToHex } from 'viem'
-import { UnknownContentTypeError } from '../../errors/utils.js'
-import type { Prettify } from '../../types.js'
-
-export type AbiEncodeAs = 'json' | 'zlib' | 'cbor' | 'uri'
-
-type AbiContentType = 1 | 2 | 4 | 8
-
-const abiEncodeMap = {
-  json: 1,
-  zlib: 2,
-  cbor: 4,
-  uri: 8,
-} as const
-type AbiEncodeMap = typeof abiEncodeMap
-
-type GetAbiContentType<TEncodeAs extends AbiEncodeAs> = AbiEncodeMap[TEncodeAs]
-
-export type EncodeAbiParameters<TEncodeAs extends AbiEncodeAs = AbiEncodeAs> =
-  TEncodeAs extends 'uri'
-    ? {
-        encodeAs: TEncodeAs
-        data: string | null
-      }
-    : {
-        encodeAs: TEncodeAs
-        data: Record<any, any> | null
-      }
-
-export type EncodedAbi<TContentType extends AbiContentType = AbiContentType> = {
-  contentType: TContentType
-  encodedData: Hex
-}
-
-export type EncodeAbiReturnType<TContentType extends AbiContentType> =
-  EncodedAbi<TContentType>
-
-export const contentTypeToEncodeAs = (
-  contentType: AbiContentType,
-): AbiEncodeAs => {
-  switch (contentType) {
-    case 1:
-      return 'json'
-    case 2:
-      return 'zlib'
-    case 4:
-      return 'cbor'
-    case 8:
-      return 'uri'
-    default:
-      throw new UnknownContentTypeError({ contentType })
-  }
-}
-
-export const encodeAsToContentType = (
-  encodeAs: AbiEncodeAs,
-): AbiContentType => {
-  const contentType = abiEncodeMap[encodeAs]
-  if (contentType === undefined) {
-    throw new UnknownContentTypeError({ contentType: encodeAs })
-  }
-  return contentType
-}
-
-export const encodeAbi = async <
-  TEncodeAs extends AbiEncodeAs,
-  TContentType extends GetAbiContentType<TEncodeAs>,
->({
-  encodeAs,
-  data,
-}: EncodeAbiParameters<TEncodeAs>): Promise<
-  Prettify<EncodeAbiReturnType<TContentType>>
-> => {
-  let contentType: AbiContentType
-  let encodedData: Hex = '0x'
-  switch (encodeAs) {
-    case 'json':
-      contentType = 1
-      if (data) encodedData = stringToHex(JSON.stringify(data))
-      break
-    case 'zlib': {
-      contentType = 2
-      if (data) {
-        const { deflate } = await import('pako/dist/pako_deflate.min.js')
-        encodedData = bytesToHex(deflate(JSON.stringify(data)))
-      }
-      break
-    }
-    case 'cbor': {
-      contentType = 4
-      if (data) {
-        const { cborEncode } = await import('@ensdomains/address-encoder/utils')
-        encodedData = bytesToHex(new Uint8Array(cborEncode(data)))
-      }
-      break
-    }
-    default: {
-      contentType = 8
-      if (data) encodedData = stringToHex(data as string)
-      break
-    }
-  }
-  return { contentType: contentType as TContentType, encodedData }
-}

package/src/utils/encoders/encodeClearRecords.ts

@@ -1,9 +0,0 @@
-import { type Hex, encodeFunctionData } from 'viem'
-import { publicResolverClearRecordsSnippet } from '../../contracts/publicResolver.js'
-
-export const encodeClearRecords = (namehash: Hex) =>
-  encodeFunctionData({
-    abi: publicResolverClearRecordsSnippet,
-    functionName: 'clearRecords',
-    args: [namehash],
-  })

package/src/utils/encoders/encodeSetAbi.ts

@@ -1,21 +0,0 @@
-import { type Hex, encodeFunctionData } from 'viem'
-import { publicResolverSetAbiSnippet } from '../../contracts/publicResolver.js'
-import type { EncodedAbi } from './encodeAbi.js'
-
-export type EncodeSetAbiParameters = {
-  namehash: Hex
-} & EncodedAbi
-
-export type EncodeSetAbiReturnType = Hex
-
-export const encodeSetAbi = ({
-  namehash,
-  contentType,
-  encodedData,
-}: EncodeSetAbiParameters): EncodeSetAbiReturnType => {
-  return encodeFunctionData({
-    abi: publicResolverSetAbiSnippet,
-    functionName: 'setABI',
-    args: [namehash, BigInt(contentType), encodedData],
-  })
-}

package/src/utils/encoders/encodeSetAddr.ts

@@ -1,32 +0,0 @@
-import { type Address, type Hex, bytesToHex, encodeFunctionData } from 'viem'
-import { publicResolverSetAddrSnippet } from '../../contracts/publicResolver.js'
-import { getCoderFromCoin } from '../normaliseCoinId.js'
-
-export type EncodeSetAddrParameters = {
-  namehash: Hex
-  coin: string | number
-  value: Address | string | null
-}
-
-export type EncodeSetAddrReturnType = Hex
-
-export const encodeSetAddr = ({
-  namehash,
-  coin,
-  value,
-}: EncodeSetAddrParameters): EncodeSetAddrReturnType => {
-  const coder = getCoderFromCoin(coin)
-  const inputCoinType = coder.coinType
-  let encodedAddress: Hex | Uint8Array = value ? coder.decode(value) : '0x'
-  if (inputCoinType === 60 && encodedAddress === '0x')
-    encodedAddress = coder.decode('0x0000000000000000000000000000000000000000')
-  if (typeof encodedAddress !== 'string') {
-    encodedAddress = bytesToHex(encodedAddress)
-  }
-
-  return encodeFunctionData({
-    abi: publicResolverSetAddrSnippet,
-    functionName: 'setAddr',
-    args: [namehash, BigInt(inputCoinType), encodedAddress],
-  })
-}

package/src/utils/encoders/encodeSetContentHash.ts

@@ -1,25 +0,0 @@
-import { type Hex, encodeFunctionData } from 'viem'
-import { publicResolverSetContenthashSnippet } from '../../contracts/publicResolver.js'
-import { encodeContentHash } from '../contentHash.js'
-
-export type EncodeSetContentHashParameters = {
-  namehash: Hex
-  contentHash: string | null
-}
-
-export type EncodeSetContentHashReturnType = Hex
-
-export const encodeSetContentHash = ({
-  namehash,
-  contentHash,
-}: EncodeSetContentHashParameters): EncodeSetContentHashReturnType => {
-  let encodedHash: Hex = '0x'
-  if (contentHash) {
-    encodedHash = encodeContentHash(contentHash)
-  }
-  return encodeFunctionData({
-    abi: publicResolverSetContenthashSnippet,
-    functionName: 'setContenthash',
-    args: [namehash, encodedHash],
-  })
-}

package/src/utils/encoders/encodeSetText.ts

@@ -1,22 +0,0 @@
-import { type Hex, encodeFunctionData } from 'viem'
-import { publicResolverSetTextSnippet } from '../../contracts/publicResolver.js'
-
-export type EncodeSetTextParameters = {
-  namehash: Hex
-  key: string
-  value: string | null
-}
-
-export type EncodeSetTextReturnType = Hex
-
-export const encodeSetText = ({
-  namehash,
-  key,
-  value,
-}: EncodeSetTextParameters): EncodeSetTextReturnType => {
-  return encodeFunctionData({
-    abi: publicResolverSetTextSnippet,
-    functionName: 'setText',
-    args: [namehash, key, value ?? ''],
-  })
-}