@ensdomains/ensjs 4.0.2 → 4.0.3-alpha.11

package/src/contracts/index.ts

@@ -40,8 +40,23 @@ export {
   ethRegistrarControllerRegisterSnippet,
   ethRegistrarControllerRenewSnippet,
   ethRegistrarControllerRentPriceSnippet,
+  ethRegistrarControllerNameRegisteredEventSnippet,
 } from './ethRegistrarController.js'
 export { getChainContractAddress } from './getChainContractAddress.js'
+export {
+  legacyEthRegistrarControllerAvailableSnippet,
+  legacyEthRegistrarControllerCommitSnippet,
+  legacyEthRegistrarControllerCommitmentsSnippet,
+  legacyEthRegistrarControllerMakeCommitmentSnippet,
+  legacyEthRegistrarControllerMakeCommitmentWithConfigSnippet,
+  legacyEthRegistrarControllerRegisterSnippet,
+  legacyEthRegistrarControllerRegisterWithConfigSnippet,
+  legacyEthRegistrarControllerRenewSnippet,
+  legacyEthRegistrarControllerRentPriceSnippet,
+  legacyEthRegistrarControllerSupportsInterfaceSnippet,
+  legacyEthRegistrarControllerTransferOwnershipSnippet,
+  legacyEthRegistrarControllerNameRegisteredEventSnippet as legacyNameRegisteredEventSnippet,
+} from './legacyEthRegistrarController.js'
 export {
   multicallGetCurrentBlockTimestampSnippet,
   multicallTryAggregateSnippet,

package/src/contracts/legacyEthRegistrarController.ts

@@ -0,0 +1,194 @@
+export const legacyEthRegistrarControllerAvailableSnippet = [
+  {
+    constant: true,
+    inputs: [{ internalType: 'string', name: 'name', type: 'string' }],
+    name: 'available',
+    outputs: [{ internalType: 'bool', name: '', type: 'bool' }],
+    payable: false,
+    stateMutability: 'view',
+    type: 'function',
+  },
+] as const
+
+export const legacyEthRegistrarControllerCommitSnippet = [
+  {
+    constant: false,
+    inputs: [{ internalType: 'bytes32', name: 'commitment', type: 'bytes32' }],
+    name: 'commit',
+    outputs: [],
+    payable: false,
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+] as const
+
+export const legacyEthRegistrarControllerCommitmentsSnippet = [
+  {
+    constant: true,
+    inputs: [{ internalType: 'bytes32', name: '', type: 'bytes32' }],
+    name: 'commitments',
+    outputs: [{ internalType: 'uint256', name: '', type: 'uint256' }],
+    payable: false,
+    stateMutability: 'view',
+    type: 'function',
+  },
+] as const
+
+export const legacyEthRegistrarControllerMakeCommitmentSnippet = [
+  {
+    constant: true,
+    inputs: [
+      { internalType: 'string', name: 'name', type: 'string' },
+      { internalType: 'address', name: 'owner', type: 'address' },
+      { internalType: 'bytes32', name: 'secret', type: 'bytes32' },
+    ],
+    name: 'makeCommitment',
+    outputs: [{ internalType: 'bytes32', name: '', type: 'bytes32' }],
+    payable: false,
+    stateMutability: 'pure',
+    type: 'function',
+  },
+] as const
+
+export const legacyEthRegistrarControllerMakeCommitmentWithConfigSnippet = [
+  {
+    constant: true,
+    inputs: [
+      { internalType: 'string', name: 'name', type: 'string' },
+      { internalType: 'address', name: 'owner', type: 'address' },
+      { internalType: 'bytes32', name: 'secret', type: 'bytes32' },
+      { internalType: 'address', name: 'resolver', type: 'address' },
+      { internalType: 'address', name: 'addr', type: 'address' },
+    ],
+    name: 'makeCommitmentWithConfig',
+    outputs: [{ internalType: 'bytes32', name: '', type: 'bytes32' }],
+    payable: false,
+    stateMutability: 'pure',
+    type: 'function',
+  },
+] as const
+
+export const legacyEthRegistrarControllerRegisterSnippet = [
+  {
+    constant: false,
+    inputs: [
+      { internalType: 'string', name: 'name', type: 'string' },
+      { internalType: 'address', name: 'owner', type: 'address' },
+      { internalType: 'uint256', name: 'duration', type: 'uint256' },
+      { internalType: 'bytes32', name: 'secret', type: 'bytes32' },
+    ],
+    name: 'register',
+    outputs: [],
+    payable: true,
+    stateMutability: 'payable',
+    type: 'function',
+  },
+] as const
+
+export const legacyEthRegistrarControllerRegisterWithConfigSnippet = [
+  {
+    constant: false,
+    inputs: [
+      { internalType: 'string', name: 'name', type: 'string' },
+      { internalType: 'address', name: 'owner', type: 'address' },
+      { internalType: 'uint256', name: 'duration', type: 'uint256' },
+      { internalType: 'bytes32', name: 'secret', type: 'bytes32' },
+      { internalType: 'address', name: 'resolver', type: 'address' },
+      { internalType: 'address', name: 'addr', type: 'address' },
+    ],
+    name: 'registerWithConfig',
+    outputs: [],
+    payable: true,
+    stateMutability: 'payable',
+    type: 'function',
+  },
+] as const
+
+export const legacyEthRegistrarControllerRenewSnippet = [
+  {
+    constant: false,
+    inputs: [
+      { internalType: 'string', name: 'name', type: 'string' },
+      { internalType: 'uint256', name: 'duration', type: 'uint256' },
+    ],
+    name: 'renew',
+    outputs: [],
+    payable: true,
+    stateMutability: 'payable',
+    type: 'function',
+  },
+] as const
+
+export const legacyEthRegistrarControllerRentPriceSnippet = [
+  {
+    constant: true,
+    inputs: [
+      { internalType: 'string', name: 'name', type: 'string' },
+      { internalType: 'uint256', name: 'duration', type: 'uint256' },
+    ],
+    name: 'rentPrice',
+    outputs: [{ internalType: 'uint256', name: '', type: 'uint256' }],
+    payable: false,
+    stateMutability: 'view',
+    type: 'function',
+  },
+] as const
+
+export const legacyEthRegistrarControllerSupportsInterfaceSnippet = [
+  {
+    constant: true,
+    inputs: [{ internalType: 'bytes4', name: 'interfaceID', type: 'bytes4' }],
+    name: 'supportsInterface',
+    outputs: [{ internalType: 'bool', name: '', type: 'bool' }],
+    payable: false,
+    stateMutability: 'pure',
+    type: 'function',
+  },
+] as const
+
+export const legacyEthRegistrarControllerTransferOwnershipSnippet = [
+  {
+    constant: false,
+    inputs: [{ internalType: 'address', name: 'newOwner', type: 'address' }],
+    name: 'transferOwnership',
+    outputs: [],
+    payable: false,
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+] as const
+
+export const legacyEthRegistrarControllerNameRegisteredEventSnippet = [
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: false, internalType: 'string', name: 'name', type: 'string' },
+      {
+        indexed: true,
+        internalType: 'bytes32',
+        name: 'label',
+        type: 'bytes32',
+      },
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'owner',
+        type: 'address',
+      },
+      {
+        indexed: false,
+        internalType: 'uint256',
+        name: 'cost',
+        type: 'uint256',
+      },
+      {
+        indexed: false,
+        internalType: 'uint256',
+        name: 'expires',
+        type: 'uint256',
+      },
+    ],
+    name: 'NameRegistered',
+    type: 'event',
+  },
+] as const

package/src/errors/register.ts

@@ -0,0 +1,22 @@
+import type { Address } from 'viem'
+import { BaseError } from './base.js'
+import { EMPTY_ADDRESS } from '../utils/consts.js'
+
+export class LegacyRegistrationInvalidConfigError extends BaseError {
+  override name = 'LegacyRegistrationInvalidConfigError'
+
+  constructor({
+    resolverAddress,
+    address,
+  }: {
+    resolverAddress?: Address
+    address?: Address
+  }) {
+    super(`Resolver address is required when setting an address`, {
+      metaMessages: [
+        `- resolverAddress: ${resolverAddress || EMPTY_ADDRESS}`,
+        `- addr: ${address || EMPTY_ADDRESS}`,
+      ],
+    })
+  }
+}

package/src/errors/version.ts

@@ -1 +1 @@
-export const version = 'v4.0.2-alpha.5'
+export const version = 'v4.0.3-alpha.11'

package/src/functions/wallet/legacyCommitName.ts

@@ -0,0 +1,127 @@
+import {
+  encodeFunctionData,
+  type Account,
+  type Hash,
+  type SendTransactionParameters,
+  type Transport,
+} from 'viem'
+import { sendTransaction } from 'viem/actions'
+import type { ChainWithEns, ClientWithAccount } from '../../contracts/consts.js'
+import { legacyEthRegistrarControllerCommitSnippet } from '../../contracts/legacyEthRegistrarController.js'
+import { getChainContractAddress } from '../../contracts/getChainContractAddress.js'
+import { UnsupportedNameTypeError } from '../../errors/general.js'
+import type {
+  Prettify,
+  SimpleTransactionRequest,
+  WriteTransactionParameters,
+} from '../../types.js'
+import { getNameType } from '../../utils/getNameType.js'
+import {
+  makeLegacyCommitment,
+  type LegacyRegistrationParameters,
+} from '../../utils/legacyRegisterHelpers.js'
+import { EMPTY_ADDRESS } from '../../utils/consts.js'
+
+export type LegacyCommitNameDataParameters = LegacyRegistrationParameters
+
+export type LegacyCommitNameDataReturnType = SimpleTransactionRequest
+
+export type LegacyCommitNameParameters<
+  TChain extends ChainWithEns,
+  TAccount extends Account | undefined,
+  TChainOverride extends ChainWithEns | undefined,
+> = Prettify<
+  LegacyCommitNameDataParameters &
+    WriteTransactionParameters<TChain, TAccount, TChainOverride>
+>
+
+export type LegacyCommitNameReturnType = Hash
+
+export const makeFunctionData = <
+  TChain extends ChainWithEns,
+  TAccount extends Account | undefined,
+>(
+  wallet: ClientWithAccount<Transport, TChain, TAccount>,
+  args: LegacyCommitNameDataParameters,
+): LegacyCommitNameDataReturnType => {
+  const nameType = getNameType(args.name)
+  if (nameType !== 'eth-2ld')
+    throw new UnsupportedNameTypeError({
+      nameType,
+      supportedNameTypes: ['eth-2ld'],
+      details: 'Only 2ld-eth name registration is supported',
+    })
+
+  return {
+    to: getChainContractAddress({
+      client: wallet,
+      contract: 'legacyEthRegistrarController',
+    }),
+    data: encodeFunctionData({
+      abi: legacyEthRegistrarControllerCommitSnippet,
+      functionName: 'commit',
+      args: [makeLegacyCommitment(args)],
+    }),
+  }
+}
+
+/**
+ * Commits a name to be registered
+ * @param wallet - {@link ClientWithAccount}
+ * @param parameters - {@link LegacyCommitNameParameters}
+ * @returns Transaction hash. {@link LegacyCommitNameReturnType}
+ *
+ * @example
+ * import { createWalletClient, custom } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { addEnsContracts } from '@ensdomains/ensjs'
+ * import { commitName } from '@ensdomains/ensjs/wallet'
+ * import { randomSecret } from '@ensdomains/ensjs/utils'
+ *
+ * const wallet = createWalletClient({
+ *   chain: addEnsContracts(mainnet),
+ *   transport: custom(window.ethereum),
+ * })
+ * const secret = randomSecret()
+ * const hash = await commitName(wallet, {
+ *   name: 'example.eth',
+ *   owner: '0xFe89cc7aBB2C4183683ab71653C4cdc9B02D44b7',
+ *   duration: 31536000, // 1 year
+ *   secret,
+ * })
+ * // 0x...
+ */
+async function legacyCommitName<
+  TChain extends ChainWithEns,
+  TAccount extends Account | undefined,
+  TChainOverride extends ChainWithEns | undefined = ChainWithEns,
+>(
+  wallet: ClientWithAccount<Transport, TChain, TAccount>,
+  {
+    name,
+    owner,
+    duration,
+    secret,
+    resolverAddress = EMPTY_ADDRESS,
+    address = EMPTY_ADDRESS,
+    ...txArgs
+  }: LegacyCommitNameParameters<TChain, TAccount, TChainOverride>,
+): Promise<LegacyCommitNameReturnType> {
+  const data = makeFunctionData(wallet, {
+    name,
+    owner,
+    duration,
+    secret,
+    resolverAddress,
+    address,
+  })
+  const writeArgs = {
+    ...data,
+    ...txArgs,
+  } as SendTransactionParameters<TChain, TAccount, TChainOverride>
+  return sendTransaction(wallet, writeArgs)
+}
+
+legacyCommitName.makeFunctionData = makeFunctionData
+
+export default legacyCommitName

package/src/functions/wallet/legacyRegisterName.ts

@@ -0,0 +1,161 @@
+import {
+  encodeFunctionData,
+  type Account,
+  type Hash,
+  type SendTransactionParameters,
+  type Transport,
+} from 'viem'
+import { sendTransaction } from 'viem/actions'
+import type { ChainWithEns, ClientWithAccount } from '../../contracts/consts.js'
+import { getChainContractAddress } from '../../contracts/getChainContractAddress.js'
+import { UnsupportedNameTypeError } from '../../errors/general.js'
+import type {
+  Prettify,
+  SimpleTransactionRequest,
+  WriteTransactionParameters,
+} from '../../types.js'
+import { getNameType } from '../../utils/getNameType.js'
+import {
+  makeLegacyRegistrationTuple,
+  type LegacyRegistrationParameters,
+  isLegacyRegistrationWithConfigParameters,
+  makeLegacyRegistrationWithConfigTuple,
+} from '../../utils/legacyRegisterHelpers.js'
+import {
+  legacyEthRegistrarControllerRegisterSnippet,
+  legacyEthRegistrarControllerRegisterWithConfigSnippet,
+} from '../../contracts/legacyEthRegistrarController.js'
+
+export type LegacyRegisterNameDataParameters = LegacyRegistrationParameters & {
+  /** Value of registration */
+  value: bigint
+}
+
+export type LegacyRegisterNameDataReturnType = SimpleTransactionRequest & {
+  value: bigint
+}
+
+export type LegacyRegisterNameParameters<
+  TChain extends ChainWithEns,
+  TAccount extends Account | undefined,
+  TChainOverride extends ChainWithEns | undefined,
+> = Prettify<
+  LegacyRegisterNameDataParameters &
+    WriteTransactionParameters<TChain, TAccount, TChainOverride>
+>
+
+export type LegacyRegisterNameReturnType = Hash
+
+export const makeFunctionData = <
+  TChain extends ChainWithEns,
+  TAccount extends Account | undefined,
+>(
+  wallet: ClientWithAccount<Transport, TChain, TAccount>,
+  { value, ...args }: LegacyRegisterNameDataParameters,
+): LegacyRegisterNameDataReturnType => {
+  const nameType = getNameType(args.name)
+  if (nameType !== 'eth-2ld')
+    throw new UnsupportedNameTypeError({
+      nameType,
+      supportedNameTypes: ['eth-2ld'],
+      details: 'Only 2ld-eth name registration is supported',
+    })
+
+  const data = isLegacyRegistrationWithConfigParameters(args)
+    ? encodeFunctionData({
+        abi: legacyEthRegistrarControllerRegisterWithConfigSnippet,
+        functionName: 'registerWithConfig',
+        args: makeLegacyRegistrationWithConfigTuple(args),
+      })
+    : encodeFunctionData({
+        abi: legacyEthRegistrarControllerRegisterSnippet,
+        functionName: 'register',
+        args: makeLegacyRegistrationTuple(args),
+      })
+
+  return {
+    to: getChainContractAddress({
+      client: wallet,
+      contract: 'legacyEthRegistrarController',
+    }),
+    data,
+    value,
+  }
+}
+
+/**
+ * Registers a name on ENS
+ * @param wallet - {@link ClientWithAccount}
+ * @param parameters - {@link RegisterNameParameters}
+ * @returns Transaction hash. {@link LegacyRegisterNameReturnType}
+ *
+ * @example
+ * import { createPublicClient, createWalletClient, http, custom } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { addEnsContracts } from '@ensdomains/ensjs'
+ * import { getPrice } from '@ensdomains/ensjs/public'
+ * import { randomSecret } from '@ensdomains/ensjs/utils'
+ * import { commitName, registerName } from '@ensdomains/ensjs/wallet'
+ *
+ * const mainnetWithEns = addEnsContracts(mainnet)
+ * const client = createPublicClient({
+ *   chain: mainnetWithEns,
+ *   transport: http(),
+ * })
+ * const wallet = createWalletClient({
+ *   chain: mainnetWithEns,
+ *   transport: custom(window.ethereum),
+ * })
+ * const secret = randomSecret()
+ * const params = {
+ *   name: 'example.eth',
+ *   owner: '0xFe89cc7aBB2C4183683ab71653C4cdc9B02D44b7',
+ *   duration: 31536000, // 1 year
+ *   secret,
+ * }
+ *
+ * const commitmentHash = await commitName(wallet, params)
+ * await client.waitForTransactionReceipt({ hash: commitmentHash }) // wait for commitment to finalise
+ * await new Promise((resolve) => setTimeout(resolve, 60 * 1_000)) // wait for commitment to be valid
+ *
+ * const { base, premium } = await getPrice(client, { nameOrNames: params.name, duration: params.duration })
+ * const value = (base + premium) * 110n / 100n // add 10% to the price for buffer
+ * const hash = await registerName(wallet, { ...params, value })
+ * // 0x...
+ */
+async function legacyRegisterName<
+  TChain extends ChainWithEns,
+  TAccount extends Account | undefined,
+  TChainOverride extends ChainWithEns | undefined = ChainWithEns,
+>(
+  wallet: ClientWithAccount<Transport, TChain, TAccount>,
+  {
+    name,
+    owner,
+    duration,
+    secret,
+    resolverAddress,
+    address,
+    value,
+    ...txArgs
+  }: LegacyRegisterNameParameters<TChain, TAccount, TChainOverride>,
+): Promise<LegacyRegisterNameReturnType> {
+  const data = makeFunctionData(wallet, {
+    name,
+    owner,
+    duration,
+    secret,
+    resolverAddress,
+    address,
+    value,
+  })
+  const writeArgs = {
+    ...data,
+    ...txArgs,
+  } as SendTransactionParameters<TChain, TAccount, TChainOverride>
+  return sendTransaction(wallet, writeArgs)
+}
+
+legacyRegisterName.makeFunctionData = makeFunctionData
+
+export default legacyRegisterName

package/src/utils/index.ts

@@ -104,6 +104,21 @@ export {
   saveLabel,
   saveName,
 } from './labels.js'
+export {
+  makeLegacyCommitment,
+  makeLegacyCommitmentFromTuple,
+  makeLegacyCommitmentTuple,
+  makeLegacyCommitmentWithConfigTuple,
+  makeLegacyRegistrationTuple,
+  makeLegacyRegistrationWithConfigTuple,
+  isLegacyRegistrationWithConfigParameters,
+  type LegacyCommitmentTuple,
+  type LegacyCommitmentWithConfigTuple,
+  type LegacyRegistrationParameters,
+  type LegacyRegistrationWithConfigParameters,
+  type LegacyRegistrationTuple,
+  type LegacyRegistrationWithConfigTuple,
+} from './legacyRegisterHelpers.js'
 export { makeSafeSecondsDate } from './makeSafeSecondsDate.js'
 export {
   beautify,

package/src/utils/legacyRegisterHelpers.ts

@@ -0,0 +1,147 @@
+import {
+  keccak256,
+  labelhash,
+  type Address,
+  type Hex,
+  encodePacked,
+} from 'viem'
+import { EMPTY_ADDRESS } from './consts.js'
+import { LegacyRegistrationInvalidConfigError } from '../errors/register.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)
+}