Mint Onchain Subnames on Ethereum or L2

BASE_RPC_URL=https://your-base-rpc.example
WALLET_PRIVATE_KEY=0xYOUR_PRIVATE_KEY

import 'dotenv/config';
import { createMintClient } from '@thenamespace/mint-manager';
import {
  createPublicClient,
  createWalletClient,
  http,
  type Hex,
} from 'viem';
import { privateKeyToAccount } from 'viem/accounts';
import { base } from 'viem/chains';

const rpcUrl = process.env.BASE_RPC_URL;
const privateKey = process.env.WALLET_PRIVATE_KEY as Hex | undefined;

if (!rpcUrl) throw new Error('Missing BASE_RPC_URL');
if (!privateKey) throw new Error('Missing WALLET_PRIVATE_KEY');

export const account = privateKeyToAccount(privateKey);
export const mintClient = createMintClient({
  mintSource: 'my-app',
  // Share one endpoint between the SDK's reads and your viem clients, so
  // the availability check and the transaction cannot disagree about
  // chain state. The SDK default is shared and rate limited.
  customRpcUrls: { [base.id]: rpcUrl },
});
export const publicClient = createPublicClient({
  chain: base,
  transport: http(rpcUrl),
});
export const walletClient = createWalletClient({
  account,
  chain: base,
  transport: http(rpcUrl),
});

import { account, mintClient } from './clients';

export const fullName = 'alice.example.eth';

export async function checkSubname() {
  const check = await mintClient.checkName(fullName, {
    minterAddress: account.address,
    expiryInYears: 1,
  });

  if (check.status !== 'available') {
    // The advice depends on the obstacle. A taken or reserved label means
    // try another one; an allowlist or token gate fails the same way for
    // every label, so sending the user back to the name field wastes
    // their time.
    throw new Error(
      `${fullName} is ${check.status}: ${check.reasons.join(', ')}`,
    );
  }

  console.log({
    priceEth: check.estimatedPriceEth,
    feeEth: check.estimatedFeeEth,
    chainId: check.chainId,
  });

  return check;
}

import { parseEther } from 'viem';
import { ChainName } from '@thenamespace/mint-manager';
import { account, mintClient } from './clients';
import { checkSubname } from './check';

export async function getTransaction() {
  const check = await checkSubname();

  // Cap what the signed quote may charge. Prices are quoted per request
  // and can move between the quote and the signature; without this, the
  // new price is simply charged.
  const quoted = parseEther(
    (check.estimatedPriceEth + check.estimatedFeeEth).toFixed(18),
  );

  return mintClient.prepareMint(check, {
    minterAddress: account.address,
    owner: account.address,
    expiryInYears: 1,
    maxValue: quoted,
    records: {
      texts: [
        { key: 'description', value: 'Minted with Namespace' },
      ],
      addresses: [
        { chain: ChainName.Ethereum, value: account.address },
      ],
    },
  });
}

import { MintManagerError } from '@thenamespace/mint-manager';
import {
  account,
  publicClient,
  walletClient,
} from './clients';
import { getTransaction } from './transaction';

async function main() {
  const transaction = await getTransaction();

  const { request } = await publicClient.simulateContract({
    account,
    address: transaction.contractAddress,
    abi: transaction.abi,
    functionName: transaction.functionName,
    args: transaction.args,
    value: transaction.value,
  });

  const hash = await walletClient.writeContract(request);
  console.log(`Submitted transaction: ${hash}`);
}

main().catch((error: unknown) => {
  if (error instanceof MintManagerError) {
    // Codes are stable across minor versions; match on them rather than
    // on message text.
    console.error(error.code, error.message, error.details);
    process.exitCode = 1;
    return;
  }

  console.error(error);
  process.exitCode = 1;
});