ethagent 1.1.1 → 2.0.0

package/src/identity/ens/ensAutomation.ts

@@ -0,0 +1,29 @@
+export {
+  ENS_AUTOMATION_RESOLVER_ABI,
+  ENS_PUBLIC_RESOLVER_ADDRESS_MAINNET,
+} from './ensAutomation/contracts.js'
+export type {
+  EncodedEnsTransaction,
+  EnsAutomationReadClient,
+  EnsRegistryAction,
+  EnsRootPreflightArgs,
+  EnsRootPreflightResult,
+  EnsSetupBlockedPlan,
+  EnsSetupPlan,
+  EnsSetupPreflight,
+  EnsSetupPreflightArgs,
+  EnsSubdomainDeletePlan,
+  EnsSubdomainDeletePreflightArgs,
+  EnsSubdomainDeletePreflightResult,
+  OperatorSetDiff,
+  TokenOwnerReadClient,
+} from './ensAutomation/types.js'
+export { preflightEnsSetup } from './ensAutomation/setup.js'
+export { preflightEnsRoot } from './ensAutomation/root.js'
+export {
+  encodeEnsRecordsTransaction,
+  encodeEnsRegistryTransaction,
+} from './ensAutomation/transactions.js'
+export { isRootEthName } from './ensAutomation/names.js'
+export { preflightDeleteSubdomain } from './ensAutomation/delete.js'
+export { compareOperatorSets } from './ensAutomation/operators.js'

package/src/identity/ens/ensLookup/client.ts

@@ -0,0 +1,43 @@
+import { createPublicClient, fallback, http, type PublicClient } from 'viem'
+import { mainnet } from 'viem/chains'
+import { ENS_RPC_URLS, RPC_TIMEOUT_MS } from './constants.js'
+
+export function createMainnetClient(): PublicClient {
+  const transports = ENS_RPC_URLS.map(url => http(url, { retryCount: 0, timeout: RPC_TIMEOUT_MS }))
+  return createPublicClient({
+    chain: mainnet,
+    transport: transports.length === 1 ? transports[0]! : fallback(transports, { retryCount: 0 }),
+  })
+}
+
+class AbortedError extends Error {
+  constructor() { super('Aborted') }
+}
+
+class TimedOutError extends Error {
+  constructor(label: string) { super(`${label} timed out`) }
+}
+
+export function withDeadline<T>(promise: Promise<T>, ms: number, label: string, signal?: AbortSignal): Promise<T> {
+  if (signal?.aborted) return Promise.reject(new AbortedError())
+  return new Promise<T>((resolve, reject) => {
+    const timer = setTimeout(() => reject(new TimedOutError(label)), ms)
+    const onAbort = () => {
+      clearTimeout(timer)
+      reject(new AbortedError())
+    }
+    signal?.addEventListener('abort', onAbort, { once: true })
+    promise.then(
+      value => {
+        clearTimeout(timer)
+        signal?.removeEventListener('abort', onAbort)
+        resolve(value)
+      },
+      err => {
+        clearTimeout(timer)
+        signal?.removeEventListener('abort', onAbort)
+        reject(err)
+      },
+    )
+  })
+}

package/src/identity/ens/ensLookup/constants.ts

@@ -0,0 +1,26 @@
+import { parseAbi, type Address } from 'viem'
+
+export const RPC_TIMEOUT_MS = 8_000
+
+export const ENS_REGISTRY_ADDRESS_MAINNET = '0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e' as Address
+export const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000' as Address
+
+export const ENS_RPC_URLS = [
+  'https://ethereum.publicnode.com',
+  'https://eth.llamarpc.com',
+  'https://rpc.ankr.com/eth',
+] as const
+
+export const ETH_NAME_PATTERN = /^([a-z0-9-]+.)+eth$/i
+
+export const ENS_REGISTRY_ABI = parseAbi([
+  'function owner(bytes32 node) view returns (address)',
+  'function resolver(bytes32 node) view returns (address)',
+])
+
+export const RESOLVER_ABI = parseAbi([
+  'function addr(bytes32 node) view returns (address)',
+  'function text(bytes32 node, string key) view returns (string)',
+  'function setText(bytes32 node, string key, string value)',
+  'function multicall(bytes[] data) returns (bytes[])',
+])

package/src/identity/ens/ensLookup/discovery.ts

@@ -0,0 +1,70 @@
+import type { Address } from 'viem'
+import type { DiscoverOptions, EnsNameDiscoveryResult } from './types.js'
+import { RPC_TIMEOUT_MS } from './constants.js'
+import { createMainnetClient } from './client.js'
+import { isEthDomain, normalizeEthDomain, splitSubdomainName } from './names.js'
+
+export async function discoverOwnedEnsNames(
+  ownerAddress: Address,
+  opts: DiscoverOptions = {},
+): Promise<string[]> {
+  const result = await discoverOwnedEnsNameDetails(ownerAddress, opts)
+  return result.names
+}
+
+export async function discoverOwnedEnsNameDetails(
+  ownerAddress: Address,
+  opts: DiscoverOptions = {},
+): Promise<EnsNameDiscoveryResult> {
+  const rpcTimeoutMs = opts.rpcTimeoutMs ?? RPC_TIMEOUT_MS
+  const controller = new AbortController()
+  const onParentAbort = () => controller.abort()
+  opts.signal?.addEventListener('abort', onParentAbort, { once: true })
+  const budgetTimer = setTimeout(() => controller.abort(), rpcTimeoutMs)
+  try {
+    const client = opts.publicClient ?? createMainnetClient()
+    if (controller.signal.aborted) {
+      return { status: 'error', names: [], sourcesChecked: [], errors: ['ENS name lookup was cancelled'] }
+    }
+    try {
+      const primary = await client.getEnsName({ address: ownerAddress })
+      const names = new Set<string>()
+      if (primary) {
+        const normalized = normalizeEthDomain(primary)
+        if (normalized && normalized.endsWith('.eth')) {
+          if (isRootEthName(normalized)) {
+            names.add(normalized)
+          } else {
+            const parts = splitSubdomainName(normalized)
+            if (parts && isRootEthName(parts.parent)) names.add(parts.parent)
+          }
+        }
+      }
+      return {
+        status: 'ok',
+        names: [...names].sort((a, b) => a.localeCompare(b)),
+        sourcesChecked: ['ENS reverse resolver'],
+        errors: [],
+      }
+    } catch (err) {
+      return {
+        status: 'error',
+        names: [],
+        sourcesChecked: [],
+        errors: [formatDiscoveryError(err)],
+      }
+    }
+  } finally {
+    clearTimeout(budgetTimer)
+    opts.signal?.removeEventListener('abort', onParentAbort)
+  }
+}
+
+function formatDiscoveryError(err: unknown): string {
+  return err instanceof Error ? err.message : String(err)
+}
+
+function isRootEthName(value: string): boolean {
+  const normalized = normalizeEthDomain(value)
+  return isEthDomain(normalized) && normalized.split('.').length === 2
+}

package/src/identity/ens/ensLookup/names.ts

@@ -0,0 +1,34 @@
+import { ETH_NAME_PATTERN } from './constants.js'
+
+export function isEthDomain(value: string): boolean {
+  const trimmed = value.trim().toLowerCase()
+  if (!trimmed.endsWith('.eth')) return false
+  if (trimmed === '.eth') return false
+  return ETH_NAME_PATTERN.test(trimmed)
+}
+
+export function normalizeEthDomain(value: string): string {
+  return value.trim().toLowerCase().replace(/\.+$/, '')
+}
+
+export function sanitizeSubdomainPrefix(value: string): string {
+  return value
+    .toLowerCase()
+    .replace(/[^a-z0-9-]/g, '-')
+    .replace(/-+/g, '-')
+    .replace(/^-|-$/g, '')
+}
+
+type SubdomainParts = { parent: string; label: string }
+
+export function splitSubdomainName(fullName: string): SubdomainParts | null {
+  const trimmed = fullName.trim().toLowerCase()
+  if (!isEthDomain(trimmed)) return null
+  const dot = trimmed.indexOf('.')
+  if (dot <= 0 || dot === trimmed.length - 1) return null
+  const label = trimmed.slice(0, dot)
+  const parent = trimmed.slice(dot + 1)
+  if (!isEthDomain(parent)) return null
+  if (!/^[a-z0-9-]+$/.test(label)) return null
+  return { parent, label }
+}

package/src/identity/ens/ensLookup/records.ts

@@ -0,0 +1,45 @@
+import { encodeFunctionData, namehash, type Address, type Hex } from 'viem'
+import type { DiscoverOptions } from './types.js'
+import { RESOLVER_ABI } from './constants.js'
+import { splitSubdomainName } from './names.js'
+import { readResolverAddress } from './resolve.js'
+
+export type EncodedEnsRecordTransaction = {
+  resolverAddress: Address
+  data: Hex
+  multicall: boolean
+  calls: Hex[]
+}
+
+export async function encodeSetEthagentTextRecords(
+  fullName: string,
+  records: Record<string, string>,
+  opts: DiscoverOptions = {},
+): Promise<EncodedEnsRecordTransaction> {
+  if (!splitSubdomainName(fullName)) {
+    throw new Error('Agent ENS records must be written to a subdomain, not a root .eth name')
+  }
+  const resolver = await readResolverAddress(fullName, opts)
+  if (!resolver) {
+    throw new Error(`no resolver set on ${fullName} - set one in the official ENS app first`)
+  }
+  const node = namehash(fullName)
+  const entries = Object.entries(records)
+  if (entries.length === 0) {
+    throw new Error('No ENS records to update')
+  }
+  const calls: Hex[] = entries.map(([key, value]) => encodeFunctionData({
+    abi: RESOLVER_ABI,
+    functionName: 'setText',
+    args: [node, key, value],
+  }))
+  if (calls.length === 1) {
+    return { resolverAddress: resolver, data: calls[0]!, multicall: false, calls }
+  }
+  const data = encodeFunctionData({
+    abi: RESOLVER_ABI,
+    functionName: 'multicall',
+    args: [calls],
+  })
+  return { resolverAddress: resolver, data, multicall: true, calls }
+}

package/src/identity/ens/ensLookup/resolve.ts

@@ -0,0 +1,75 @@
+import { getAddress, namehash, type Address } from 'viem'
+import type { DiscoverOptions } from './types.js'
+import { ENS_REGISTRY_ABI, ENS_REGISTRY_ADDRESS_MAINNET, RESOLVER_ABI, RPC_TIMEOUT_MS, ZERO_ADDRESS } from './constants.js'
+import { createMainnetClient, withDeadline } from './client.js'
+import { isEthDomain, normalizeEthDomain } from './names.js'
+
+export async function resolveEnsAddress(name: string, opts: DiscoverOptions = {}): Promise<Address | null> {
+  const trimmed = normalizeEthDomain(name)
+  if (!isEthDomain(trimmed)) return null
+  const client = opts.publicClient ?? createMainnetClient()
+  try {
+    const addr = await withDeadline(
+      client.getEnsAddress({ name: trimmed }),
+      opts.rpcTimeoutMs ?? RPC_TIMEOUT_MS,
+      'getEnsAddress',
+      opts.signal,
+    )
+    return addr ? getAddress(addr) : null
+  } catch {
+    return null
+  }
+}
+
+export async function readResolverAddress(fullName: string, opts: DiscoverOptions = {}): Promise<Address | null> {
+  if (!isEthDomain(fullName)) return null
+  const client = opts.publicClient ?? createMainnetClient()
+  try {
+    const node = namehash(fullName)
+    const resolver = await withDeadline(
+      client.readContract({
+        address: ENS_REGISTRY_ADDRESS_MAINNET,
+        abi: ENS_REGISTRY_ABI,
+        functionName: 'resolver',
+        args: [node],
+      }),
+      opts.rpcTimeoutMs ?? RPC_TIMEOUT_MS,
+      'registry.resolver',
+      opts.signal,
+    ) as Address
+    return resolver === ZERO_ADDRESS ? null : resolver
+  } catch {
+    return null
+  }
+}
+
+export async function readEthagentTextRecords(
+  fullName: string,
+  keys: readonly string[],
+  opts: DiscoverOptions = {},
+): Promise<Record<string, string>> {
+  const out: Record<string, string> = {}
+  if (!isEthDomain(fullName)) return out
+  const resolver = await readResolverAddress(fullName, opts)
+  if (!resolver) return out
+  const client = opts.publicClient ?? createMainnetClient()
+  const node = namehash(fullName)
+  for (const key of keys) {
+    try {
+      const value = await withDeadline(
+        client.readContract({
+          address: resolver,
+          abi: RESOLVER_ABI,
+          functionName: 'text',
+          args: [node, key],
+        }),
+        opts.rpcTimeoutMs ?? RPC_TIMEOUT_MS,
+        `resolver.text(${key})`,
+        opts.signal,
+      ) as string
+      if (value) out[key] = value
+    } catch {
+    }
+  }
+  return out
+}

package/src/identity/ens/ensLookup/tokenReference.ts

@@ -0,0 +1,17 @@
+import { getAddress, isAddress } from 'viem'
+import type { EnsAgentTokenReference } from './types.js'
+
+export function parseAgentTokenReference(value: string): Omit<EnsAgentTokenReference, 'node' | 'resolverAddress'> | null {
+  const match = value.trim().match(/^eip155:(\d+):(0x[0-9a-fA-F]{40}):(\d+)$/)
+  if (!match) return null
+  const chainId = Number(match[1])
+  if (!Number.isSafeInteger(chainId) || chainId <= 0) return null
+  const registry = match[2]
+  const tokenId = match[3]
+  if (!registry || !isAddress(registry, { strict: false }) || !tokenId) return null
+  return {
+    chainId,
+    identityRegistryAddress: getAddress(registry),
+    agentId: BigInt(tokenId),
+  }
+}

package/src/identity/ens/ensLookup/types.ts

@@ -0,0 +1,38 @@
+import type { Address, Hex, PublicClient } from 'viem'
+
+export type EnsValidation =
+  | { ok: true; resolvedAddress: Address; resolverAddress: Address }
+  | {
+      ok: false
+      reason:
+        | 'no-owner'
+        | 'no-resolver'
+        | 'address-mismatch'
+        | 'lookup-failed'
+        | 'token-owner-mismatch'
+        | 'token-owner-lookup-failed'
+      detail?: string
+    }
+
+export type DiscoverOptions = {
+  signal?: AbortSignal
+  budgetMs?: number
+  rpcTimeoutMs?: number
+  scanWindowBlocks?: bigint
+  publicClient?: PublicClient
+}
+
+export type EnsNameDiscoveryResult = {
+  status: 'ok' | 'partial' | 'error'
+  names: string[]
+  sourcesChecked: string[]
+  errors: string[]
+}
+
+export type EnsAgentTokenReference = {
+  chainId: number
+  identityRegistryAddress: Address
+  agentId: bigint
+  node: Hex
+  resolverAddress: Address
+}

package/src/identity/ens/ensLookup/validation.ts

@@ -0,0 +1,72 @@
+import { getAddress, namehash, type Address } from 'viem'
+import type { DiscoverOptions, EnsValidation } from './types.js'
+import { ENS_REGISTRY_ABI, ENS_REGISTRY_ADDRESS_MAINNET, RPC_TIMEOUT_MS, ZERO_ADDRESS } from './constants.js'
+import { createMainnetClient, withDeadline } from './client.js'
+import { isEthDomain, splitSubdomainName } from './names.js'
+
+export async function validateAgentEnsLink(
+  fullName: string,
+  expectedOwner: Address,
+  opts: DiscoverOptions = {},
+): Promise<EnsValidation> {
+  if (!isEthDomain(fullName)) {
+    return { ok: false, reason: 'lookup-failed', detail: 'not a valid .eth name' }
+  }
+  if (!splitSubdomainName(fullName)) {
+    return { ok: false, reason: 'lookup-failed', detail: 'agent ENS name must be a subdomain, not a root .eth name' }
+  }
+  const client = opts.publicClient ?? createMainnetClient()
+  const node = namehash(fullName)
+  let resolver: Address
+  try {
+    const owner = await withDeadline(
+      client.readContract({
+        address: ENS_REGISTRY_ADDRESS_MAINNET,
+        abi: ENS_REGISTRY_ABI,
+        functionName: 'owner',
+        args: [node],
+      }),
+      opts.rpcTimeoutMs ?? RPC_TIMEOUT_MS,
+      'registry.owner',
+      opts.signal,
+    ) as Address
+    if (owner === ZERO_ADDRESS) {
+      return { ok: false, reason: 'no-owner', detail: 'name does not exist on ENS' }
+    }
+    resolver = await withDeadline(
+      client.readContract({
+        address: ENS_REGISTRY_ADDRESS_MAINNET,
+        abi: ENS_REGISTRY_ABI,
+        functionName: 'resolver',
+        args: [node],
+      }),
+      opts.rpcTimeoutMs ?? RPC_TIMEOUT_MS,
+      'registry.resolver',
+      opts.signal,
+    ) as Address
+    if (resolver === ZERO_ADDRESS) {
+      return { ok: false, reason: 'no-resolver', detail: 'name has no resolver set' }
+    }
+  } catch (err) {
+    return { ok: false, reason: 'lookup-failed', detail: err instanceof Error ? err.message : String(err) }
+  }
+  let resolved: Address | null
+  try {
+    resolved = await withDeadline(
+      client.getEnsAddress({ name: fullName }),
+      opts.rpcTimeoutMs ?? RPC_TIMEOUT_MS,
+      'getEnsAddress',
+      opts.signal,
+    )
+  } catch (err) {
+    return { ok: false, reason: 'lookup-failed', detail: err instanceof Error ? err.message : String(err) }
+  }
+  if (!resolved) {
+    return { ok: false, reason: 'address-mismatch', detail: 'name resolves to no address' }
+  }
+  const checksumResolved = getAddress(resolved)
+  if (checksumResolved.toLowerCase() !== expectedOwner.toLowerCase()) {
+    return { ok: false, reason: 'address-mismatch', detail: `name resolves to ${checksumResolved}` }
+  }
+  return { ok: true, resolvedAddress: checksumResolved, resolverAddress: getAddress(resolver) }
+}

package/src/identity/ens/ensLookup.ts

@@ -0,0 +1,19 @@
+export type {
+  DiscoverOptions,
+  EnsAgentTokenReference,
+  EnsNameDiscoveryResult,
+  EnsValidation,
+} from './ensLookup/types.js'
+export type { EncodedEnsRecordTransaction } from './ensLookup/records.js'
+export {
+  isEthDomain,
+  normalizeEthDomain,
+  sanitizeSubdomainPrefix,
+  splitSubdomainName,
+} from './ensLookup/names.js'
+export { createMainnetClient } from './ensLookup/client.js'
+export { resolveEnsAddress, readEthagentTextRecords, readResolverAddress } from './ensLookup/resolve.js'
+export { parseAgentTokenReference } from './ensLookup/tokenReference.js'
+export { discoverOwnedEnsNameDetails, discoverOwnedEnsNames } from './ensLookup/discovery.js'
+export { validateAgentEnsLink } from './ensLookup/validation.js'
+export { encodeSetEthagentTextRecords } from './ensLookup/records.js'

package/src/identity/ens/ensRegistration.ts

@@ -0,0 +1,199 @@
+import {
+  encodeAbiParameters,
+  encodeFunctionData,
+  getAddress,
+  keccak256,
+  namehash,
+  parseAbi,
+  type Address,
+  type Hex,
+  type PublicClient,
+} from 'viem'
+
+export const ETH_REGISTRAR_CONTROLLER_MAINNET = '0x253553366Da8546fC250F225fe3d25d0C782303b' as Address
+export const PUBLIC_RESOLVER_MAINNET = '0x231b0Ee14048e9dCcD1d247744d114a4EB5E8E63' as Address
+export const MIN_COMMIT_AGE_SECONDS = 60
+export const MAX_COMMIT_AGE_SECONDS = 86_400
+export const ONE_YEAR_SECONDS = 31_557_600
+export const REGISTER_VALUE_BUFFER_BIPS = 500n
+
+const CONTROLLER_ABI = parseAbi([
+  'function available(string name) view returns (bool)',
+  'function rentPrice(string name, uint256 duration) view returns (uint256 base, uint256 premium)',
+  'function commit(bytes32 commitment)',
+  'function register(string name, address owner, uint256 duration, bytes32 secret, address resolver, bytes[] data, bool reverseRecord, uint16 ownerControlledFuses) payable',
+])
+
+const RESOLVER_ABI = parseAbi([
+  'function setAddr(bytes32 node, address a)',
+])
+
+export type RegistrableNameValidation =
+  | { ok: true; label: string }
+  | { ok: false; reason: 'too-short' | 'too-long' | 'invalid-characters' | 'leading-hyphen' | 'trailing-hyphen' | 'contains-dot'; detail: string }
+
+export function validateRegistrableName(value: string): RegistrableNameValidation {
+  const label = value.trim().toLowerCase()
+  if (label.includes('.')) {
+    return { ok: false, reason: 'contains-dot', detail: 'Enter only the label, not a full .eth name.' }
+  }
+  if (label.length < 3) {
+    return { ok: false, reason: 'too-short', detail: 'Names must be at least 3 characters.' }
+  }
+  if (label.length > 64) {
+    return { ok: false, reason: 'too-long', detail: 'Names must be 64 characters or fewer.' }
+  }
+  if (label.startsWith('-')) {
+    return { ok: false, reason: 'leading-hyphen', detail: 'Names cannot start with a hyphen.' }
+  }
+  if (label.endsWith('-')) {
+    return { ok: false, reason: 'trailing-hyphen', detail: 'Names cannot end with a hyphen.' }
+  }
+  if (!/^[a-z0-9-]+$/.test(label)) {
+    return { ok: false, reason: 'invalid-characters', detail: 'Names use lowercase letters, numbers, and hyphens only.' }
+  }
+  return { ok: true, label }
+}
+
+type RentPrice = {
+  base: bigint
+  premium: bigint
+  total: bigint
+}
+
+export type EnsRegistrationReadClient = Pick<PublicClient, 'readContract'>
+
+export async function readRentPrice(
+  client: EnsRegistrationReadClient,
+  label: string,
+  durationSeconds: bigint,
+): Promise<RentPrice> {
+  const result = await client.readContract({
+    address: ETH_REGISTRAR_CONTROLLER_MAINNET,
+    abi: CONTROLLER_ABI,
+    functionName: 'rentPrice',
+    args: [label, durationSeconds],
+  }) as readonly [bigint, bigint]
+  const [base, premium] = result
+  return { base, premium, total: base + premium }
+}
+
+export async function readNameAvailable(
+  client: EnsRegistrationReadClient,
+  label: string,
+): Promise<boolean> {
+  return await client.readContract({
+    address: ETH_REGISTRAR_CONTROLLER_MAINNET,
+    abi: CONTROLLER_ABI,
+    functionName: 'available',
+    args: [label],
+  }) as boolean
+}
+
+type CommitmentArgs = {
+  label: string
+  owner: Address
+  durationSeconds: bigint
+  secret: Hex
+  resolver?: Address
+  setAddrToOwner?: boolean
+  reverseRecord?: boolean
+  ownerControlledFuses?: number
+}
+
+type CommitmentBuild = {
+  commitment: Hex
+  resolver: Address
+  data: Hex[]
+  reverseRecord: boolean
+  ownerControlledFuses: number
+}
+
+export function buildCommitment(args: CommitmentArgs): CommitmentBuild {
+  const owner = getAddress(args.owner)
+  const resolver = getAddress(args.resolver ?? PUBLIC_RESOLVER_MAINNET)
+  const reverseRecord = args.reverseRecord ?? false
+  const ownerControlledFuses = args.ownerControlledFuses ?? 0
+  const data: Hex[] = []
+  if (args.setAddrToOwner ?? true) {
+    data.push(encodeFunctionData({
+      abi: RESOLVER_ABI,
+      functionName: 'setAddr',
+      args: [namehash(`${args.label}.eth`), owner],
+    }))
+  }
+  const commitment = keccak256(encodeAbiParameters(
+    [
+      { type: 'string' },
+      { type: 'address' },
+      { type: 'uint256' },
+      { type: 'bytes32' },
+      { type: 'address' },
+      { type: 'bytes[]' },
+      { type: 'bool' },
+      { type: 'uint16' },
+    ],
+    [args.label, owner, args.durationSeconds, args.secret, resolver, data, reverseRecord, ownerControlledFuses],
+  ))
+  return { commitment, resolver, data, reverseRecord, ownerControlledFuses }
+}
+
+export function encodeCommitTransaction(commitment: Hex): { to: Address; data: Hex } {
+  return {
+    to: ETH_REGISTRAR_CONTROLLER_MAINNET,
+    data: encodeFunctionData({
+      abi: CONTROLLER_ABI,
+      functionName: 'commit',
+      args: [commitment],
+    }),
+  }
+}
+
+type RegisterTransactionArgs = {
+  label: string
+  owner: Address
+  durationSeconds: bigint
+  secret: Hex
+  rentPrice: RentPrice
+  resolver?: Address
+  setAddrToOwner?: boolean
+  reverseRecord?: boolean
+  ownerControlledFuses?: number
+}
+
+export function encodeRegisterTransaction(args: RegisterTransactionArgs): { to: Address; data: Hex; value: Hex } {
+  const owner = getAddress(args.owner)
+  const built = buildCommitment({
+    label: args.label,
+    owner,
+    durationSeconds: args.durationSeconds,
+    secret: args.secret,
+    ...(args.resolver !== undefined ? { resolver: args.resolver } : {}),
+    ...(args.setAddrToOwner !== undefined ? { setAddrToOwner: args.setAddrToOwner } : {}),
+    ...(args.reverseRecord !== undefined ? { reverseRecord: args.reverseRecord } : {}),
+    ...(args.ownerControlledFuses !== undefined ? { ownerControlledFuses: args.ownerControlledFuses } : {}),
+  })
+  const data = encodeFunctionData({
+    abi: CONTROLLER_ABI,
+    functionName: 'register',
+    args: [args.label, owner, args.durationSeconds, args.secret, built.resolver, built.data, built.reverseRecord, built.ownerControlledFuses],
+  })
+  const buffered = (args.rentPrice.total * (10000n + REGISTER_VALUE_BUFFER_BIPS)) / 10000n
+  return {
+    to: ETH_REGISTRAR_CONTROLLER_MAINNET,
+    data,
+    value: ('0x' + buffered.toString(16)) as Hex,
+  }
+}
+
+export function generateRegistrationSecret(): Hex {
+  const bytes = new Uint8Array(32)
+  if (typeof globalThis.crypto?.getRandomValues === 'function') {
+    globalThis.crypto.getRandomValues(bytes)
+  } else {
+    for (let i = 0; i < bytes.length; i++) bytes[i] = Math.floor(Math.random() * 256)
+  }
+  let hex = '0x'
+  for (const byte of bytes) hex += byte.toString(16).padStart(2, '0')
+  return hex as Hex
+}