ETH Registrar

ETHRegistrar.makeCommitment(
    label string,        // "alice" for alice.eth (label only, not full name)
    owner address,       // The address that will own the name
    secret bytes32,      // A randomly generated 32-byte secret
    subregistry IRegistry, // Child registry to set (or address(0) for none)
    resolver address,    // Resolver contract to set
    duration uint64,     // Registration duration in seconds
    referrer bytes32     // Referral identifier (or bytes32(0))
)
 
// For example
makeCommitment(
    "alice",
    0x1234...,
    0xabcd...,           // Random secret, generate off-chain
    address(0),          // No subregistry
    0x5678...,           // Resolver address
    31536000,            // 1 year in seconds
    bytes32(0)           // No referrer
);

ETHRegistrar.commit(commitment bytes32)

ETHRegistrar.register(
    label string,          // Same label used in makeCommitment
    owner address,         // Same owner used in makeCommitment
    secret bytes32,        // Same secret used in makeCommitment
    subregistry IRegistry, // Same subregistry used in makeCommitment
    resolver address,      // Same resolver used in makeCommitment
    duration uint64,       // Same duration used in makeCommitment
    paymentToken IERC20,   // ERC20 token to pay with (must be approved)
    referrer bytes32       // Same referrer used in makeCommitment
) returns (uint256 tokenId)
 
// For example
register(
    "alice",
    0x1234...,
    0xabcd...,             // Same secret as in commit step
    address(0),
    0x5678...,
    31536000,
    0x9abc...,             // USDC token address
    bytes32(0)
);

ETHRegistrar.renew(
    label string,        // The label to renew
    duration uint64,     // Duration to extend by (in seconds)
    paymentToken IERC20, // ERC20 token to pay with (must be approved)
    referrer bytes32     // Referral identifier
)

import {
  createPublicClient,
  createWalletClient,
  http,
  keccak256,
  toHex,
} from 'viem'
import { mainnet } from 'viem/chains'
 
const client = createPublicClient({ chain: mainnet, transport: http() })
const wallet = createWalletClient({ chain: mainnet, transport: http() })
 
const label = 'alice'
const owner = '0x...' // Your address
const duration = 31536000n // 1 year in seconds
const secret = keccak256(toHex(crypto.randomUUID())) // Random secret
const resolver = '0x...' // Resolver address
const subregistry = '0x0000000000000000000000000000000000000000'
const paymentToken = '0x...' // ERC20 token address
const referrer = '0x0000000000000000000000000000000000000000000000000000000000000000'
 
// 1. Check availability
const available = await client.readContract({
  address: ethRegistrarAddress,
  abi: ethRegistrarAbi,
  functionName: 'isAvailable',
  args: [label],
})
 
if (!available) throw new Error('Name not available')
 
// 2. Get the price
const [base, premium] = await client.readContract({
  address: ethRegistrarAddress,
  abi: ethRegistrarAbi,
  functionName: 'rentPrice',
  args: [label, owner, duration, paymentToken],
})
 
// 3. Approve the registrar to spend the payment token
const totalCost = base + premium
await wallet.writeContract({
  address: paymentToken,
  abi: erc20Abi,
  functionName: 'approve',
  args: [ethRegistrarAddress, totalCost],
})
 
// 4. Create and submit commitment
const commitment = await client.readContract({
  address: ethRegistrarAddress,
  abi: ethRegistrarAbi,
  functionName: 'makeCommitment',
  args: [label, owner, secret, subregistry, resolver, duration, referrer],
})
 
await wallet.writeContract({
  address: ethRegistrarAddress,
  abi: ethRegistrarAbi,
  functionName: 'commit',
  args: [commitment],
})
 
// 5. Wait at least MIN_COMMITMENT_AGE (e.g., 60 seconds)
// ... wait ...
 
// 6. Register
await wallet.writeContract({
  address: ethRegistrarAddress,
  abi: ethRegistrarAbi,
  functionName: 'register',
  args: [
    label,
    owner,
    secret,
    subregistry,
    resolver,
    duration,
    paymentToken,
    referrer,
  ],
})

const [renewPrice] = await client.readContract({
  address: ethRegistrarAddress,
  abi: ethRegistrarAbi,
  functionName: 'rentPrice',
  args: [label, owner, duration, paymentToken],
})
 
// Approve the registrar to spend the payment token
await wallet.writeContract({
  address: paymentToken,
  abi: erc20Abi,
  functionName: 'approve',
  args: [ethRegistrarAddress, renewPrice],
})
 
await wallet.writeContract({
  address: ethRegistrarAddress,
  abi: ethRegistrarAbi,
  functionName: 'renew',
  args: [label, duration, paymentToken, referrer],
})