@ensdomains/ensjs 4.1.1 → 5.0.0-alpha.0

package/src/functions/wallet/setResolver.ts

@@ -1,127 +0,0 @@
-import {
-  type Account,
-  type Address,
-  type Hash,
-  type SendTransactionParameters,
-  type Transport,
-  encodeFunctionData,
-} from 'viem'
-import { sendTransaction } from 'viem/actions'
-import type { ChainWithEns, ClientWithAccount } from '../../contracts/consts.js'
-import { getChainContractAddress } from '../../contracts/getChainContractAddress.js'
-import { nameWrapperSetResolverSnippet } from '../../contracts/nameWrapper.js'
-import { registrySetResolverSnippet } from '../../contracts/registry.js'
-import type {
-  Prettify,
-  SimpleTransactionRequest,
-  WriteTransactionParameters,
-} from '../../types.js'
-import { namehash } from '../../utils/normalise.js'
-
-export type SetResolverDataParameters = {
-  /** Name to set resolver for */
-  name: string
-  /** Contract to set resolver on */
-  contract: 'registry' | 'nameWrapper'
-  /** Resolver address to set */
-  resolverAddress: Address
-}
-
-export type SetResolverDataReturnType = SimpleTransactionRequest
-
-export type SetResolverParameters<
-  TChain extends ChainWithEns,
-  TAccount extends Account | undefined,
-  TChainOverride extends ChainWithEns | undefined,
-> = Prettify<
-  SetResolverDataParameters &
-    WriteTransactionParameters<TChain, TAccount, TChainOverride>
->
-
-export type SetResolverReturnType = Hash
-
-export const makeFunctionData = <
-  TChain extends ChainWithEns,
-  TAccount extends Account | undefined,
->(
-  wallet: ClientWithAccount<Transport, TChain, TAccount>,
-  { name, contract, resolverAddress }: SetResolverDataParameters,
-): SetResolverDataReturnType => {
-  if (contract !== 'registry' && contract !== 'nameWrapper')
-    throw new Error(`Unknown contract: ${contract}`)
-
-  const to = getChainContractAddress({
-    client: wallet,
-    contract: contract === 'nameWrapper' ? 'ensNameWrapper' : 'ensRegistry',
-  })
-
-  const args = [namehash(name), resolverAddress] as const
-  const functionName = 'setResolver'
-
-  if (contract === 'nameWrapper')
-    return {
-      to,
-      data: encodeFunctionData({
-        abi: nameWrapperSetResolverSnippet,
-        functionName,
-        args,
-      }),
-    }
-
-  return {
-    to,
-    data: encodeFunctionData({
-      abi: registrySetResolverSnippet,
-      functionName,
-      args,
-    }),
-  }
-}
-
-/**
- * Sets a resolver for a name.
- * @param wallet - {@link ClientWithAccount}
- * @param parameters - {@link SetResolverParameters}
- * @returns Transaction hash. {@link SetResolverReturnType}
- *
- * @example
- * import { createWalletClient, custom } from 'viem'
- * import { mainnet } from 'viem/chains'
- * import { addEnsContracts } from '@ensdomains/ensjs'
- * import { setResolver } from '@ensdomains/ensjs/wallet'
- *
- * const wallet = createWalletClient({
- *   chain: addEnsContracts(mainnet),
- *   transport: custom(window.ethereum),
- * })
- * const hash = await setResolver(wallet, {
- *   name: 'ens.eth',
- *   contract: 'registry',
- *   resolverAddress: '0x4976fb03C32e5B8cfe2b6cCB31c09Ba78EBaBa41',
- * })
- * // 0x...
- */
-async function setResolver<
-  TChain extends ChainWithEns,
-  TAccount extends Account | undefined,
-  TChainOverride extends ChainWithEns | undefined = ChainWithEns,
->(
-  wallet: ClientWithAccount<Transport, TChain, TAccount>,
-  {
-    name,
-    contract,
-    resolverAddress,
-    ...txArgs
-  }: SetResolverParameters<TChain, TAccount, TChainOverride>,
-): Promise<SetResolverReturnType> {
-  const data = makeFunctionData(wallet, { name, contract, resolverAddress })
-  const writeArgs = {
-    ...data,
-    ...txArgs,
-  } as SendTransactionParameters<TChain, TAccount, TChainOverride>
-  return sendTransaction(wallet, writeArgs)
-}
-
-setResolver.makeFunctionData = makeFunctionData
-
-export default setResolver

package/src/functions/wallet/setTextRecord.ts

@@ -1,108 +0,0 @@
-import type {
-  Account,
-  Address,
-  Hash,
-  SendTransactionParameters,
-  Transport,
-} from 'viem'
-import { sendTransaction } from 'viem/actions'
-import type { ChainWithEns, ClientWithAccount } from '../../contracts/consts.js'
-import type {
-  Prettify,
-  SimpleTransactionRequest,
-  WriteTransactionParameters,
-} from '../../types.js'
-import { encodeSetText } from '../../utils/encoders/encodeSetText.js'
-import { namehash } from '../../utils/normalise.js'
-
-export type SetTextRecordDataParameters = {
-  /** The name to set a text record for */
-  name: string
-  /** The text record key to set */
-  key: string
-  /** The text record value to set */
-  value: string | null
-  /** The resolver address to use */
-  resolverAddress: Address
-}
-
-export type SetTextRecordDataReturnType = SimpleTransactionRequest
-
-export type SetTextRecordParameters<
-  TChain extends ChainWithEns,
-  TAccount extends Account | undefined,
-  TChainOverride extends ChainWithEns | undefined,
-> = Prettify<
-  SetTextRecordDataParameters &
-    WriteTransactionParameters<TChain, TAccount, TChainOverride>
->
-
-export type SetTextRecordReturnType = Hash
-
-export const makeFunctionData = <
-  TChain extends ChainWithEns,
-  TAccount extends Account | undefined,
->(
-  _wallet: ClientWithAccount<Transport, TChain, TAccount>,
-  { name, key, value, resolverAddress }: SetTextRecordDataParameters,
-): SetTextRecordDataReturnType => {
-  return {
-    to: resolverAddress,
-    data: encodeSetText({ namehash: namehash(name), key, value }),
-  }
-}
-
-/**
- * Sets a text record for a name on a resolver.
- * @param wallet - {@link ClientWithAccount}
- * @param parameters - {@link SetTextRecordParameters}
- * @returns Transaction hash. {@link SetTextRecordReturnType}
- *
- * @example
- * import { createWalletClient, custom } from 'viem'
- * import { mainnet } from 'viem/chains'
- * import { addEnsContracts } from '@ensdomains/ensjs'
- * import { setTextRecord } from '@ensdomains/ensjs/wallet'
- *
- * const wallet = createWalletClient({
- *   chain: addEnsContracts(mainnet),
- *   transport: custom(window.ethereum),
- * })
- * const hash = await setTextRecord(wallet, {
- *   name: 'ens.eth',
- *   key: 'foo',
- *   value: 'bar',
- *   resolverAddress: '0x4976fb03C32e5B8cfe2b6cCB31c09Ba78EBaBa41',
- * })
- * // 0x...
- */
-async function setTextRecord<
-  TChain extends ChainWithEns,
-  TAccount extends Account | undefined,
-  TChainOverride extends ChainWithEns | undefined = ChainWithEns,
->(
-  wallet: ClientWithAccount<Transport, TChain, TAccount>,
-  {
-    name,
-    key,
-    value,
-    resolverAddress,
-    ...txArgs
-  }: SetTextRecordParameters<TChain, TAccount, TChainOverride>,
-): Promise<SetTextRecordReturnType> {
-  const data = makeFunctionData(wallet, {
-    name,
-    key,
-    value,
-    resolverAddress,
-  })
-  const writeArgs = {
-    ...data,
-    ...txArgs,
-  } as SendTransactionParameters<TChain, TAccount, TChainOverride>
-  return sendTransaction(wallet, writeArgs)
-}
-
-setTextRecord.makeFunctionData = makeFunctionData
-
-export default setTextRecord

package/src/functions/wallet/transferName.ts

@@ -1,264 +0,0 @@
-import {
-  type Account,
-  type Address,
-  type Hash,
-  type SendTransactionParameters,
-  type Transport,
-  encodeFunctionData,
-  labelhash,
-} from 'viem'
-import { sendTransaction } from 'viem/actions'
-import { parseAccount } from 'viem/utils'
-import {
-  baseRegistrarReclaimSnippet,
-  baseRegistrarSafeTransferFromSnippet,
-} from '../../contracts/baseRegistrar.js'
-import type { ChainWithEns, ClientWithAccount } from '../../contracts/consts.js'
-import { getChainContractAddress } from '../../contracts/getChainContractAddress.js'
-import {
-  nameWrapperSafeTransferFromSnippet,
-  nameWrapperSetSubnodeOwnerSnippet,
-} from '../../contracts/nameWrapper.js'
-import {
-  registrySetOwnerSnippet,
-  registrySetSubnodeOwnerSnippet,
-} from '../../contracts/registry.js'
-import {
-  AdditionalParameterSpecifiedError,
-  InvalidContractTypeError,
-  UnsupportedNameTypeError,
-} from '../../errors/general.js'
-import type {
-  Prettify,
-  SimpleTransactionRequest,
-  WriteTransactionParameters,
-} from '../../types.js'
-import { getNameType } from '../../utils/getNameType.js'
-import { makeLabelNodeAndParent } from '../../utils/makeLabelNodeAndParent.js'
-import { namehash } from '../../utils/normalise.js'
-
-type BaseTransferNameDataParameters = {
-  /** Name to transfer */
-  name: string
-  /** Transfer recipient */
-  newOwnerAddress: Address
-  /** Contract to use for transfer */
-  contract: 'registry' | 'nameWrapper' | 'registrar'
-  /** Reclaim ownership as registrant (registrar only) */
-  reclaim?: boolean
-  /** Transfer name as the parent owner */
-  asParent?: boolean
-}
-
-type RegistryOrNameWrapperTransferNameDataParameters = {
-  contract: 'registry' | 'nameWrapper'
-  reclaim?: never
-}
-
-type BaseRegistrarTransferNameDataParameters = {
-  contract: 'registrar'
-  reclaim?: boolean
-  asParent?: never
-}
-
-export type TransferNameDataParameters = BaseTransferNameDataParameters &
-  (
-    | RegistryOrNameWrapperTransferNameDataParameters
-    | BaseRegistrarTransferNameDataParameters
-  )
-
-export type TransferNameDataReturnType = SimpleTransactionRequest
-
-export type TransferNameParameters<
-  TChain extends ChainWithEns,
-  TAccount extends Account | undefined,
-  TChainOverride extends ChainWithEns | undefined,
-> = Prettify<
-  TransferNameDataParameters &
-    WriteTransactionParameters<TChain, TAccount, TChainOverride>
->
-
-export type TransferNameReturnType = Hash
-
-export const makeFunctionData = <
-  TChain extends ChainWithEns,
-  TAccount extends Account,
->(
-  wallet: ClientWithAccount<Transport, TChain, TAccount>,
-  {
-    name,
-    newOwnerAddress,
-    contract,
-    reclaim,
-    asParent,
-  }: TransferNameDataParameters,
-): TransferNameDataReturnType => {
-  if (reclaim && contract !== 'registrar')
-    throw new AdditionalParameterSpecifiedError({
-      parameter: 'reclaim',
-      allowedParameters: ['name', 'newOwnerAddress', 'contract'],
-      details:
-        "Can't reclaim a name from any contract other than the registrar",
-    })
-  switch (contract) {
-    case 'registry': {
-      const registryAddress = getChainContractAddress({
-        client: wallet,
-        contract: 'ensRegistry',
-      })
-      if (asParent) {
-        const { labelhash: labelhashId, parentNode } =
-          makeLabelNodeAndParent(name)
-        return {
-          to: registryAddress,
-          data: encodeFunctionData({
-            abi: registrySetSubnodeOwnerSnippet,
-            functionName: 'setSubnodeOwner',
-            args: [parentNode, labelhashId, newOwnerAddress],
-          }),
-        }
-      }
-      return {
-        to: registryAddress,
-        data: encodeFunctionData({
-          abi: registrySetOwnerSnippet,
-          functionName: 'setOwner',
-          args: [namehash(name), newOwnerAddress],
-        }),
-      }
-    }
-    case 'registrar': {
-      if (asParent)
-        throw new AdditionalParameterSpecifiedError({
-          parameter: 'asParent',
-          allowedParameters: ['name', 'newOwnerAddress', 'contract', 'reclaim'],
-          details: "Can't transfer a name as the parent owner on the registrar",
-        })
-      const nameType = getNameType(name)
-      if (nameType !== 'eth-2ld')
-        throw new UnsupportedNameTypeError({
-          nameType,
-          supportedNameTypes: ['eth-2ld'],
-          details:
-            'Only eth-2ld names can be transferred on the registrar contract',
-        })
-      const labels = name.split('.')
-      const tokenId = BigInt(labelhash(labels[0]))
-      return {
-        to: getChainContractAddress({
-          client: wallet,
-          contract: 'ensBaseRegistrarImplementation',
-        }),
-        data: reclaim
-          ? encodeFunctionData({
-              abi: baseRegistrarReclaimSnippet,
-              functionName: 'reclaim',
-              args: [tokenId, newOwnerAddress],
-            })
-          : encodeFunctionData({
-              abi: baseRegistrarSafeTransferFromSnippet,
-              functionName: 'safeTransferFrom',
-              args: [wallet.account.address, newOwnerAddress, tokenId],
-            }),
-      }
-    }
-    case 'nameWrapper': {
-      const nameWrapperAddress = getChainContractAddress({
-        client: wallet,
-        contract: 'ensNameWrapper',
-      })
-      if (asParent) {
-        const { label, parentNode } = makeLabelNodeAndParent(name)
-        return {
-          to: nameWrapperAddress,
-          data: encodeFunctionData({
-            abi: nameWrapperSetSubnodeOwnerSnippet,
-            functionName: 'setSubnodeOwner',
-            args: [parentNode, label, newOwnerAddress, 0, BigInt(0)],
-          }),
-        }
-      }
-      return {
-        to: nameWrapperAddress,
-        data: encodeFunctionData({
-          abi: nameWrapperSafeTransferFromSnippet,
-          functionName: 'safeTransferFrom',
-          args: [
-            wallet.account.address,
-            newOwnerAddress,
-            BigInt(namehash(name)),
-            BigInt(1),
-            '0x',
-          ],
-        }),
-      }
-    }
-    default:
-      throw new InvalidContractTypeError({
-        contractType: contract,
-        supportedContractTypes: ['registry', 'registrar', 'nameWrapper'],
-      })
-  }
-}
-
-/**
- * Transfers a name to a new owner.
- * @param wallet - {@link ClientWithAccount}
- * @param parameters - {@link TransferNameParameters}
- * @returns Transaction hash. {@link TransferNameReturnType}
- *
- * @example
- * import { createWalletClient, custom } from 'viem'
- * import { mainnet } from 'viem/chains'
- * import { addEnsContracts } from '@ensdomains/ensjs'
- * import { transferName } from '@ensdomains/ensjs/wallet'
- *
- * const wallet = createWalletClient({
- *   chain: addEnsContracts(mainnet),
- *   transport: custom(window.ethereum),
- * })
- * const hash = await transferName(wallet, {
- *   name: 'ens.eth',
- *   newOwnerAddress: '0xFe89cc7aBB2C4183683ab71653C4cdc9B02D44b7',
- *   contract: 'registry',
- * })
- * // 0x...
- */
-async function transferName<
-  TChain extends ChainWithEns,
-  TAccount extends Account | undefined,
-  TChainOverride extends ChainWithEns | undefined = ChainWithEns,
->(
-  wallet: ClientWithAccount<Transport, TChain, TAccount>,
-  {
-    name,
-    newOwnerAddress,
-    contract,
-    reclaim,
-    asParent,
-    ...txArgs
-  }: TransferNameParameters<TChain, TAccount, TChainOverride>,
-): Promise<TransferNameReturnType> {
-  const data = makeFunctionData(
-    {
-      ...wallet,
-      account: parseAccount((txArgs.account || wallet.account)!),
-    } as ClientWithAccount<Transport, TChain, Account>,
-    {
-      name,
-      newOwnerAddress,
-      contract,
-      reclaim,
-      asParent,
-    } as TransferNameDataParameters,
-  )
-  const writeArgs = {
-    ...data,
-    ...txArgs,
-  } as SendTransactionParameters<TChain, TAccount, TChainOverride>
-  return sendTransaction(wallet, writeArgs)
-}
-
-transferName.makeFunctionData = makeFunctionData
-
-export default transferName

package/src/functions/wallet/unwrapName.ts

@@ -1,173 +0,0 @@
-import {
-  type Account,
-  type Address,
-  type Hash,
-  type SendTransactionParameters,
-  type Transport,
-  encodeFunctionData,
-} from 'viem'
-import { sendTransaction } from 'viem/actions'
-import type { ChainWithEns, ClientWithAccount } from '../../contracts/consts.js'
-import { getChainContractAddress } from '../../contracts/getChainContractAddress.js'
-import {
-  nameWrapperUnwrapEth2ldSnippet,
-  nameWrapperUnwrapSnippet,
-} from '../../contracts/nameWrapper.js'
-import {
-  AdditionalParameterSpecifiedError,
-  RequiredParameterNotSpecifiedError,
-} from '../../errors/general.js'
-import type {
-  Eth2ldName,
-  Eth2ldNameSpecifier,
-  GetNameType,
-  SimpleTransactionRequest,
-  WriteTransactionParameters,
-} from '../../types.js'
-import { getNameType } from '../../utils/getNameType.js'
-import { makeLabelNodeAndParent } from '../../utils/makeLabelNodeAndParent.js'
-
-type BaseUnwrapNameDataParameters<TName extends string> = {
-  /** The name to unwrap */
-  name: TName
-  /** The recipient of the unwrapped name */
-  newOwnerAddress: Address
-  /** The registrant of the unwrapped name (eth-2ld only) */
-  newRegistrantAddress?: Address
-}
-
-type Eth2ldUnwrapNameDataParameters = {
-  name: Eth2ldName
-  newRegistrantAddress: Address
-}
-
-type OtherUnwrapNameDataParameters = {
-  name: string
-  newRegistrantAddress?: never
-}
-
-export type UnwrapNameDataParameters<
-  TName extends string,
-  TNameType extends GetNameType<TName> = GetNameType<TName>,
-> = BaseUnwrapNameDataParameters<TName> &
-  (TNameType extends Eth2ldNameSpecifier
-    ? Eth2ldUnwrapNameDataParameters
-    : OtherUnwrapNameDataParameters)
-
-export type UnwrapNameDataReturnType = SimpleTransactionRequest
-
-export type UnwrapNameParameters<
-  TName extends string,
-  TChain extends ChainWithEns,
-  TAccount extends Account | undefined,
-  TChainOverride extends ChainWithEns | undefined,
-> = UnwrapNameDataParameters<TName> &
-  WriteTransactionParameters<TChain, TAccount, TChainOverride>
-
-export type UnwrapNameReturnType = Hash
-
-export const makeFunctionData = <
-  TName extends string,
-  TChain extends ChainWithEns,
-  TAccount extends Account | undefined,
->(
-  wallet: ClientWithAccount<Transport, TChain, TAccount>,
-  {
-    name,
-    newOwnerAddress,
-    newRegistrantAddress,
-  }: UnwrapNameDataParameters<TName>,
-): UnwrapNameDataReturnType => {
-  const { labelhash, parentNode } = makeLabelNodeAndParent(name)
-  const nameWrapperAddress = getChainContractAddress({
-    client: wallet,
-    contract: 'ensNameWrapper',
-  })
-  const nameType = getNameType(name)
-
-  if (nameType === 'eth-2ld') {
-    if (!newRegistrantAddress)
-      throw new RequiredParameterNotSpecifiedError({
-        parameter: 'newRegistrantAddress',
-        details: 'Must provide newRegistrantAddress for eth-2ld names',
-      })
-
-    return {
-      to: nameWrapperAddress,
-      data: encodeFunctionData({
-        abi: nameWrapperUnwrapEth2ldSnippet,
-        functionName: 'unwrapETH2LD',
-        args: [labelhash, newRegistrantAddress, newOwnerAddress],
-      }),
-    }
-  }
-
-  if (newRegistrantAddress)
-    throw new AdditionalParameterSpecifiedError({
-      parameter: 'newRegistrantAddress',
-      allowedParameters: ['name', 'newOwnerAddress'],
-      details: 'newRegistrantAddress can only be specified for eth-2ld names',
-    })
-
-  return {
-    to: nameWrapperAddress,
-    data: encodeFunctionData({
-      abi: nameWrapperUnwrapSnippet,
-      functionName: 'unwrap',
-      args: [parentNode, labelhash, newOwnerAddress],
-    }),
-  }
-}
-
-/**
- * Unwraps a name.
- * @param wallet - {@link ClientWithAccount}
- * @param parameters - {@link UnwrapNameParameters}
- * @returns Transaction hash. {@link UnwrapNameReturnType}
- *
- * @example
- * import { createWalletClient, custom } from 'viem'
- * import { mainnet } from 'viem/chains'
- * import { addEnsContracts } from '@ensdomains/ensjs'
- * import { unwrapName } from '@ensdomains/ensjs/wallet'
- *
- * const wallet = createWalletClient({
- *   chain: addEnsContracts(mainnet),
- *   transport: custom(window.ethereum),
- * })
- * const hash = await unwrapName(wallet, {
- *   name: 'example.eth',
- *   newOwnerAddress: '0xFe89cc7aBB2C4183683ab71653C4cdc9B02D44b7',
- *   newRegistrantAddress: '0xFe89cc7aBB2C4183683ab71653C4cdc9B02D44b7',
- * })
- * // 0x...
- */
-async function unwrapName<
-  TName extends string,
-  TChain extends ChainWithEns,
-  TAccount extends Account | undefined,
-  TChainOverride extends ChainWithEns | undefined = ChainWithEns,
->(
-  wallet: ClientWithAccount<Transport, TChain, TAccount>,
-  {
-    name,
-    newOwnerAddress,
-    newRegistrantAddress,
-    ...txArgs
-  }: UnwrapNameParameters<TName, TChain, TAccount, TChainOverride>,
-): Promise<UnwrapNameReturnType> {
-  const data = makeFunctionData(wallet, {
-    name,
-    newOwnerAddress,
-    newRegistrantAddress,
-  } as UnwrapNameDataParameters<TName>)
-  const writeArgs = {
-    ...data,
-    ...(txArgs as WriteTransactionParameters<TChain, TAccount, TChainOverride>),
-  } as SendTransactionParameters<TChain, TAccount, TChainOverride>
-  return sendTransaction(wallet, writeArgs)
-}
-
-unwrapName.makeFunctionData = makeFunctionData
-
-export default unwrapName